{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This mounts your Google Drive to the Colab VM.\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive', force_remount=True)\n",
    "\n",
    "# Enter the foldername in your Drive where you have saved the unzipped\n",
    "# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n",
    "FOLDERNAME = None\n",
    "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
    "\n",
    "# Now that we've mounted your Drive, this ensures that\n",
    "# the Python interpreter of the Colab VM can load\n",
    "# python files from within it.\n",
    "import sys\n",
    "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
    "\n",
    "# This downloads the CIFAR-10 dataset to your Drive\n",
    "# if it doesn't already exist.\n",
    "%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
    "!bash get_datasets.sh\n",
    "%cd /content/drive/My\\ Drive/$FOLDERNAME"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In this exercise we will implement fully-connected networks using a modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: forward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[autoreload of cs231n.layer_utils failed: Traceback (most recent call last):\n",
      "  File \"D:\\Anaconda3\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 245, in check\n",
      "    superreload(m, reload, self.old_objects)\n",
      "  File \"D:\\Anaconda3\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 394, in superreload\n",
      "    module = reload(module)\n",
      "  File \"D:\\Anaconda3\\lib\\imp.py\", line 314, in reload\n",
      "    return importlib.reload(module)\n",
      "  File \"D:\\Anaconda3\\lib\\importlib\\__init__.py\", line 169, in reload\n",
      "    _bootstrap._exec(spec, module)\n",
      "  File \"<frozen importlib._bootstrap>\", line 604, in _exec\n",
      "  File \"<frozen importlib._bootstrap_external>\", line 779, in exec_module\n",
      "  File \"<frozen importlib._bootstrap_external>\", line 916, in get_code\n",
      "  File \"<frozen importlib._bootstrap_external>\", line 846, in source_to_code\n",
      "  File \"<frozen importlib._bootstrap>\", line 219, in _call_with_frames_removed\n",
      "  File \"D:\\codes\\git\\private\\cs231\\assignment1\\cs231n\\layer_utils.py\", line 25\n",
      "    \"\"\"\n",
      "    Backward pass for the affine-relu convenience layer\n",
      "    \"\"\"e\n",
      "       ^\n",
      "SyntaxError: invalid syntax\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "\n",
    "sigmoid函数，当输出数值非常大时，其梯度会非常接近0\n",
    "\n",
    "Relu函数，当输入数值全为负数时\n",
    "\n",
    "Leaky Relu，一般不会出现此问题\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  6.750562121603446e-11\n",
      "dw error:  8.162015570444288e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "Now implement the loss and gradient for softmax and SVM in the `softmax_loss` and `svm_loss` function in `cs231n/layers.py`. These should be similar to what you implemented in `cs231n/classifiers/softmax.py` and `cs231n/classifiers/linear_svm.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.3025458445007376\n",
      "dx error:  8.234144091578429e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. Read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.52e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 9.09e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. You also need to imeplement the `sgd` function in `cs231n/optim.py`. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves about `36%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.303135\n",
      "(Epoch 0 / 10) train acc: 0.134000; val_acc: 0.119000\n",
      "(Iteration 101 / 4900) loss: 1.762772\n",
      "(Iteration 201 / 4900) loss: 1.714300\n",
      "(Iteration 301 / 4900) loss: 1.629307\n",
      "(Iteration 401 / 4900) loss: 1.580161\n",
      "(Epoch 1 / 10) train acc: 0.461000; val_acc: 0.432000\n",
      "(Iteration 501 / 4900) loss: 1.462849\n",
      "(Iteration 601 / 4900) loss: 1.614785\n",
      "(Iteration 701 / 4900) loss: 1.545342\n",
      "(Iteration 801 / 4900) loss: 1.385606\n",
      "(Iteration 901 / 4900) loss: 1.546807\n",
      "(Epoch 2 / 10) train acc: 0.496000; val_acc: 0.496000\n",
      "(Iteration 1001 / 4900) loss: 1.449638\n",
      "(Iteration 1101 / 4900) loss: 1.474147\n",
      "(Iteration 1201 / 4900) loss: 1.406565\n",
      "(Iteration 1301 / 4900) loss: 1.538574\n",
      "(Iteration 1401 / 4900) loss: 1.363421\n",
      "(Epoch 3 / 10) train acc: 0.509000; val_acc: 0.489000\n",
      "(Iteration 1501 / 4900) loss: 1.341502\n",
      "(Iteration 1601 / 4900) loss: 1.504444\n",
      "(Iteration 1701 / 4900) loss: 1.370180\n",
      "(Iteration 1801 / 4900) loss: 1.266584\n",
      "(Iteration 1901 / 4900) loss: 1.322823\n",
      "(Epoch 4 / 10) train acc: 0.534000; val_acc: 0.480000\n",
      "(Iteration 2001 / 4900) loss: 1.341655\n",
      "(Iteration 2101 / 4900) loss: 1.385520\n",
      "(Iteration 2201 / 4900) loss: 1.488443\n",
      "(Iteration 2301 / 4900) loss: 1.564046\n",
      "(Iteration 2401 / 4900) loss: 1.400317\n",
      "(Epoch 5 / 10) train acc: 0.517000; val_acc: 0.488000\n",
      "(Iteration 2501 / 4900) loss: 1.336376\n",
      "(Iteration 2601 / 4900) loss: 1.279435\n",
      "(Iteration 2701 / 4900) loss: 1.307406\n",
      "(Iteration 2801 / 4900) loss: 1.206055\n",
      "(Iteration 2901 / 4900) loss: 1.396125\n",
      "(Epoch 6 / 10) train acc: 0.511000; val_acc: 0.492000\n",
      "(Iteration 3001 / 4900) loss: 1.221770\n",
      "(Iteration 3101 / 4900) loss: 1.197638\n",
      "(Iteration 3201 / 4900) loss: 1.418647\n",
      "(Iteration 3301 / 4900) loss: 1.312230\n",
      "(Iteration 3401 / 4900) loss: 1.315403\n",
      "(Epoch 7 / 10) train acc: 0.537000; val_acc: 0.489000\n",
      "(Iteration 3501 / 4900) loss: 1.141528\n",
      "(Iteration 3601 / 4900) loss: 1.103297\n",
      "(Iteration 3701 / 4900) loss: 1.276818\n",
      "(Iteration 3801 / 4900) loss: 1.162436\n",
      "(Iteration 3901 / 4900) loss: 1.323504\n",
      "(Epoch 8 / 10) train acc: 0.521000; val_acc: 0.527000\n",
      "(Iteration 4001 / 4900) loss: 1.326817\n",
      "(Iteration 4101 / 4900) loss: 1.270618\n",
      "(Iteration 4201 / 4900) loss: 1.111012\n",
      "(Iteration 4301 / 4900) loss: 1.264157\n",
      "(Iteration 4401 / 4900) loss: 1.150263\n",
      "(Epoch 9 / 10) train acc: 0.537000; val_acc: 0.517000\n",
      "(Iteration 4501 / 4900) loss: 1.089155\n",
      "(Iteration 4601 / 4900) loss: 1.480931\n",
      "(Iteration 4701 / 4900) loss: 1.170693\n",
      "(Iteration 4801 / 4900) loss: 1.248794\n",
      "(Epoch 10 / 10) train acc: 0.571000; val_acc: 0.524000\n",
      "Validation accuracy:  0.527\n"
     ]
    }
   ],
   "source": [
    "input_size = 32 * 32 * 3\n",
    "hidden_size = 50\n",
    "num_classes = 10\n",
    "model = TwoLayerNet(input_size, hidden_size, num_classes)\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves about 36% #\n",
    "# accuracy on the validation set.                                            #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "solver = Solver(model, data,\n",
    "                    update_rule='sgd',\n",
    "                    optim_config={\n",
    "                      'learning_rate': 1e-3,\n",
    "                    },\n",
    "                    lr_decay=0.95,\n",
    "                    num_epochs=10, batch_size=100,\n",
    "                    print_every=100, verbose = True)\n",
    "solver.train()\n",
    "print('Validation accuracy: ', solver.best_val_acc)\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Debug the training\n",
    "With the default parameters we provided above, you should get a validation accuracy of about 0.36 on the validation set. This isn't very good.\n",
    "\n",
    "One strategy for getting insight into what's wrong is to plot the loss function and the accuracies on the training and validation sets during optimization.\n",
    "\n",
    "Another strategy is to visualize the weights that were learned in the first layer of the network. In most neural networks trained on visual data, the first layer weights typically show some visible structure when visualized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from cs231n.vis_utils import visualize_grid\n",
    "\n",
    "# Visualize the weights of the network\n",
    "\n",
    "def show_net_weights(net):\n",
    "    W1 = net.params['W1']\n",
    "    W1 = W1.reshape(32, 32, 3, -1).transpose(3, 0, 1, 2)\n",
    "    plt.imshow(visualize_grid(W1, padding=3).astype('uint8'))\n",
    "    plt.gca().axis('off')\n",
    "    plt.show()\n",
    "\n",
    "show_net_weights(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tune your hyperparameters\n",
    "\n",
    "**What's wrong?**. Looking at the visualizations above, we see that the loss is decreasing more or less linearly, which seems to suggest that the learning rate may be too low. Moreover, there is no gap between the training and validation accuracy, suggesting that the model we used has low capacity, and that we should increase its size. On the other hand, with a very large model we would expect to see more overfitting, which would manifest itself as a very large gap between the training and validation accuracy.\n",
    "\n",
    "**Tuning**. Tuning the hyperparameters and developing intuition for how they affect the final performance is a large part of using Neural Networks, so we want you to get a lot of practice. Below, you should experiment with different values of the various hyperparameters, including hidden layer size, learning rate, numer of training epochs, and regularization strength. You might also consider tuning the learning rate decay, but you should be able to get good performance using the default value.\n",
    "\n",
    "**Approximate results**. You should be aim to achieve a classification accuracy of greater than 48% on the validation set. Our best network gets over 52% on the validation set.\n",
    "\n",
    "**Experiment**: You goal in this exercise is to get as good of a result on CIFAR-10 as you can (52% could serve as a reference), with a fully-connected Neural Network. Feel free implement your own techniques (e.g. PCA to reduce dimensionality, or adding dropout, or adding features to the solver, etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.307513\n",
      "(Epoch 0 / 10) train acc: 0.088000; val_acc: 0.104000\n",
      "(Iteration 101 / 4900) loss: 2.296724\n",
      "(Iteration 201 / 4900) loss: 2.255150\n",
      "(Iteration 301 / 4900) loss: 2.256429\n",
      "(Iteration 401 / 4900) loss: 2.130056\n",
      "(Epoch 1 / 10) train acc: 0.237000; val_acc: 0.250000\n",
      "(Iteration 501 / 4900) loss: 2.134665\n",
      "(Iteration 601 / 4900) loss: 1.980146\n",
      "(Iteration 701 / 4900) loss: 2.039224\n",
      "(Iteration 801 / 4900) loss: 2.026954\n",
      "(Iteration 901 / 4900) loss: 2.055142\n",
      "(Epoch 2 / 10) train acc: 0.278000; val_acc: 0.291000\n",
      "(Iteration 1001 / 4900) loss: 1.980099\n",
      "(Iteration 1101 / 4900) loss: 1.945201\n",
      "(Iteration 1201 / 4900) loss: 1.986979\n",
      "(Iteration 1301 / 4900) loss: 1.863317\n",
      "(Iteration 1401 / 4900) loss: 1.880531\n",
      "(Epoch 3 / 10) train acc: 0.358000; val_acc: 0.311000\n",
      "(Iteration 1501 / 4900) loss: 1.881899\n",
      "(Iteration 1601 / 4900) loss: 1.866130\n",
      "(Iteration 1701 / 4900) loss: 2.056913\n",
      "(Iteration 1801 / 4900) loss: 1.890204\n",
      "(Iteration 1901 / 4900) loss: 1.870444\n",
      "(Epoch 4 / 10) train acc: 0.351000; val_acc: 0.354000\n",
      "(Iteration 2001 / 4900) loss: 1.810033\n",
      "(Iteration 2101 / 4900) loss: 1.850554\n",
      "(Iteration 2201 / 4900) loss: 1.660751\n",
      "(Iteration 2301 / 4900) loss: 1.670265\n",
      "(Iteration 2401 / 4900) loss: 1.772790\n",
      "(Epoch 5 / 10) train acc: 0.377000; val_acc: 0.379000\n",
      "(Iteration 2501 / 4900) loss: 1.701543\n",
      "(Iteration 2601 / 4900) loss: 1.885847\n",
      "(Iteration 2701 / 4900) loss: 1.857898\n",
      "(Iteration 2801 / 4900) loss: 1.795568\n",
      "(Iteration 2901 / 4900) loss: 1.831394\n",
      "(Epoch 6 / 10) train acc: 0.396000; val_acc: 0.386000\n",
      "(Iteration 3001 / 4900) loss: 1.721318\n",
      "(Iteration 3101 / 4900) loss: 1.716060\n",
      "(Iteration 3201 / 4900) loss: 1.561750\n",
      "(Iteration 3301 / 4900) loss: 1.841231\n",
      "(Iteration 3401 / 4900) loss: 1.701808\n",
      "(Epoch 7 / 10) train acc: 0.411000; val_acc: 0.394000\n",
      "(Iteration 3501 / 4900) loss: 1.610039\n",
      "(Iteration 3601 / 4900) loss: 1.546279\n",
      "(Iteration 3701 / 4900) loss: 1.903884\n",
      "(Iteration 3801 / 4900) loss: 1.679932\n",
      "(Iteration 3901 / 4900) loss: 1.583502\n",
      "(Epoch 8 / 10) train acc: 0.378000; val_acc: 0.403000\n",
      "(Iteration 4001 / 4900) loss: 1.714757\n",
      "(Iteration 4101 / 4900) loss: 1.729799\n",
      "(Iteration 4201 / 4900) loss: 1.730719\n",
      "(Iteration 4301 / 4900) loss: 1.474755\n",
      "(Iteration 4401 / 4900) loss: 1.666033\n",
      "(Epoch 9 / 10) train acc: 0.426000; val_acc: 0.411000\n",
      "(Iteration 4501 / 4900) loss: 1.761388\n",
      "(Iteration 4601 / 4900) loss: 1.567582\n",
      "(Iteration 4701 / 4900) loss: 1.731690\n",
      "(Iteration 4801 / 4900) loss: 1.692170\n",
      "(Epoch 10 / 10) train acc: 0.408000; val_acc: 0.412000\n",
      "50 5e-05 10 0.05\n",
      "Validation accuracy:  0.412\n",
      "(Iteration 1 / 4900) loss: 2.311166\n",
      "(Epoch 0 / 10) train acc: 0.102000; val_acc: 0.103000\n",
      "(Iteration 101 / 4900) loss: 2.297068\n",
      "(Iteration 201 / 4900) loss: 2.291126\n",
      "(Iteration 301 / 4900) loss: 2.234816\n",
      "(Iteration 401 / 4900) loss: 2.183325\n",
      "(Epoch 1 / 10) train acc: 0.260000; val_acc: 0.260000\n",
      "(Iteration 501 / 4900) loss: 2.214627\n",
      "(Iteration 601 / 4900) loss: 2.072987\n",
      "(Iteration 701 / 4900) loss: 2.050365\n",
      "(Iteration 801 / 4900) loss: 2.048613\n",
      "(Iteration 901 / 4900) loss: 1.964356\n",
      "(Epoch 2 / 10) train acc: 0.299000; val_acc: 0.291000\n",
      "(Iteration 1001 / 4900) loss: 1.977393\n",
      "(Iteration 1101 / 4900) loss: 1.874540\n",
      "(Iteration 1201 / 4900) loss: 1.876363\n",
      "(Iteration 1301 / 4900) loss: 1.957177\n",
      "(Iteration 1401 / 4900) loss: 1.882416\n",
      "(Epoch 3 / 10) train acc: 0.329000; val_acc: 0.325000\n",
      "(Iteration 1501 / 4900) loss: 1.846953\n",
      "(Iteration 1601 / 4900) loss: 1.899905\n",
      "(Iteration 1701 / 4900) loss: 1.868268\n",
      "(Iteration 1801 / 4900) loss: 1.594385\n",
      "(Iteration 1901 / 4900) loss: 1.832232\n",
      "(Epoch 4 / 10) train acc: 0.375000; val_acc: 0.360000\n",
      "(Iteration 2001 / 4900) loss: 1.889809\n",
      "(Iteration 2101 / 4900) loss: 1.742031\n",
      "(Iteration 2201 / 4900) loss: 1.741007\n",
      "(Iteration 2301 / 4900) loss: 1.837803\n",
      "(Iteration 2401 / 4900) loss: 1.764235\n",
      "(Epoch 5 / 10) train acc: 0.381000; val_acc: 0.379000\n",
      "(Iteration 2501 / 4900) loss: 1.833488\n",
      "(Iteration 2601 / 4900) loss: 1.825567\n",
      "(Iteration 2701 / 4900) loss: 1.671198\n",
      "(Iteration 2801 / 4900) loss: 1.732274\n",
      "(Iteration 2901 / 4900) loss: 1.700075\n",
      "(Epoch 6 / 10) train acc: 0.370000; val_acc: 0.387000\n",
      "(Iteration 3001 / 4900) loss: 1.663473\n",
      "(Iteration 3101 / 4900) loss: 1.821318\n",
      "(Iteration 3201 / 4900) loss: 1.706558\n",
      "(Iteration 3301 / 4900) loss: 1.619214\n",
      "(Iteration 3401 / 4900) loss: 1.710075\n",
      "(Epoch 7 / 10) train acc: 0.377000; val_acc: 0.404000\n",
      "(Iteration 3501 / 4900) loss: 1.640994\n",
      "(Iteration 3601 / 4900) loss: 1.767274\n",
      "(Iteration 3701 / 4900) loss: 1.712082\n",
      "(Iteration 3801 / 4900) loss: 1.754077\n",
      "(Iteration 3901 / 4900) loss: 1.981458\n",
      "(Epoch 8 / 10) train acc: 0.384000; val_acc: 0.412000\n",
      "(Iteration 4001 / 4900) loss: 1.858966\n",
      "(Iteration 4101 / 4900) loss: 1.611743\n",
      "(Iteration 4201 / 4900) loss: 1.660033\n",
      "(Iteration 4301 / 4900) loss: 1.700098\n",
      "(Iteration 4401 / 4900) loss: 1.743247\n",
      "(Epoch 9 / 10) train acc: 0.393000; val_acc: 0.427000\n",
      "(Iteration 4501 / 4900) loss: 1.529982\n",
      "(Iteration 4601 / 4900) loss: 1.753404\n",
      "(Iteration 4701 / 4900) loss: 1.684586\n",
      "(Iteration 4801 / 4900) loss: 1.593463\n",
      "(Epoch 10 / 10) train acc: 0.437000; val_acc: 0.427000\n",
      "50 5e-05 10 0.1\n",
      "Validation accuracy:  0.427\n",
      "(Iteration 1 / 4900) loss: 2.319100\n",
      "(Epoch 0 / 10) train acc: 0.073000; val_acc: 0.081000\n",
      "(Iteration 101 / 4900) loss: 2.308234\n",
      "(Iteration 201 / 4900) loss: 2.276654\n",
      "(Iteration 301 / 4900) loss: 2.244094\n",
      "(Iteration 401 / 4900) loss: 2.191338\n",
      "(Epoch 1 / 10) train acc: 0.238000; val_acc: 0.237000\n",
      "(Iteration 501 / 4900) loss: 2.126055\n",
      "(Iteration 601 / 4900) loss: 2.149290\n",
      "(Iteration 701 / 4900) loss: 2.048145\n",
      "(Iteration 801 / 4900) loss: 2.029723\n",
      "(Iteration 901 / 4900) loss: 2.032361\n",
      "(Epoch 2 / 10) train acc: 0.252000; val_acc: 0.287000\n",
      "(Iteration 1001 / 4900) loss: 2.151483\n",
      "(Iteration 1101 / 4900) loss: 2.053418\n",
      "(Iteration 1201 / 4900) loss: 2.067869\n",
      "(Iteration 1301 / 4900) loss: 1.906574\n",
      "(Iteration 1401 / 4900) loss: 1.963437\n",
      "(Epoch 3 / 10) train acc: 0.323000; val_acc: 0.322000\n",
      "(Iteration 1501 / 4900) loss: 2.101322\n",
      "(Iteration 1601 / 4900) loss: 1.946613\n",
      "(Iteration 1701 / 4900) loss: 1.814895\n",
      "(Iteration 1801 / 4900) loss: 1.777608\n",
      "(Iteration 1901 / 4900) loss: 1.823009\n",
      "(Epoch 4 / 10) train acc: 0.356000; val_acc: 0.350000\n",
      "(Iteration 2001 / 4900) loss: 1.817899\n",
      "(Iteration 2101 / 4900) loss: 1.750020\n",
      "(Iteration 2201 / 4900) loss: 1.724239\n",
      "(Iteration 2301 / 4900) loss: 1.868642\n",
      "(Iteration 2401 / 4900) loss: 1.858701\n",
      "(Epoch 5 / 10) train acc: 0.361000; val_acc: 0.364000\n",
      "(Iteration 2501 / 4900) loss: 1.969102\n",
      "(Iteration 2601 / 4900) loss: 1.924530\n",
      "(Iteration 2701 / 4900) loss: 1.825352\n",
      "(Iteration 2801 / 4900) loss: 1.719555\n",
      "(Iteration 2901 / 4900) loss: 1.754378\n",
      "(Epoch 6 / 10) train acc: 0.370000; val_acc: 0.382000\n",
      "(Iteration 3001 / 4900) loss: 1.796110\n",
      "(Iteration 3101 / 4900) loss: 1.758479\n",
      "(Iteration 3201 / 4900) loss: 1.648899\n",
      "(Iteration 3301 / 4900) loss: 1.742867\n",
      "(Iteration 3401 / 4900) loss: 1.661148\n",
      "(Epoch 7 / 10) train acc: 0.385000; val_acc: 0.385000\n",
      "(Iteration 3501 / 4900) loss: 1.616834\n",
      "(Iteration 3601 / 4900) loss: 1.761045\n",
      "(Iteration 3701 / 4900) loss: 1.720494\n",
      "(Iteration 3801 / 4900) loss: 1.726569\n",
      "(Iteration 3901 / 4900) loss: 1.595211\n",
      "(Epoch 8 / 10) train acc: 0.381000; val_acc: 0.402000\n",
      "(Iteration 4001 / 4900) loss: 1.688202\n",
      "(Iteration 4101 / 4900) loss: 1.604492\n",
      "(Iteration 4201 / 4900) loss: 1.698856\n",
      "(Iteration 4301 / 4900) loss: 1.724739\n",
      "(Iteration 4401 / 4900) loss: 1.625993\n",
      "(Epoch 9 / 10) train acc: 0.414000; val_acc: 0.409000\n",
      "(Iteration 4501 / 4900) loss: 1.536881\n",
      "(Iteration 4601 / 4900) loss: 1.719199\n",
      "(Iteration 4701 / 4900) loss: 1.888969\n",
      "(Iteration 4801 / 4900) loss: 1.675921\n",
      "(Epoch 10 / 10) train acc: 0.440000; val_acc: 0.419000\n",
      "50 5e-05 10 0.2\n",
      "Validation accuracy:  0.419\n",
      "(Iteration 1 / 4900) loss: 2.308983\n",
      "(Epoch 0 / 10) train acc: 0.105000; val_acc: 0.113000\n",
      "(Iteration 101 / 4900) loss: 2.281710\n",
      "(Iteration 201 / 4900) loss: 2.224532\n",
      "(Iteration 301 / 4900) loss: 2.172093\n",
      "(Iteration 401 / 4900) loss: 2.096292\n",
      "(Epoch 1 / 10) train acc: 0.258000; val_acc: 0.263000\n",
      "(Iteration 501 / 4900) loss: 2.122380\n",
      "(Iteration 601 / 4900) loss: 2.037961\n",
      "(Iteration 701 / 4900) loss: 2.017758\n",
      "(Iteration 801 / 4900) loss: 1.950678\n",
      "(Iteration 901 / 4900) loss: 2.051593\n",
      "(Epoch 2 / 10) train acc: 0.293000; val_acc: 0.309000\n",
      "(Iteration 1001 / 4900) loss: 1.926536\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1101 / 4900) loss: 1.982147\n",
      "(Iteration 1201 / 4900) loss: 1.864306\n",
      "(Iteration 1301 / 4900) loss: 2.041504\n",
      "(Iteration 1401 / 4900) loss: 2.079708\n",
      "(Epoch 3 / 10) train acc: 0.327000; val_acc: 0.333000\n",
      "(Iteration 1501 / 4900) loss: 1.762688\n",
      "(Iteration 1601 / 4900) loss: 1.815562\n",
      "(Iteration 1701 / 4900) loss: 1.793907\n",
      "(Iteration 1801 / 4900) loss: 1.913610\n",
      "(Iteration 1901 / 4900) loss: 1.700258\n",
      "(Epoch 4 / 10) train acc: 0.382000; val_acc: 0.363000\n",
      "(Iteration 2001 / 4900) loss: 1.894957\n",
      "(Iteration 2101 / 4900) loss: 1.748529\n",
      "(Iteration 2201 / 4900) loss: 1.683396\n",
      "(Iteration 2301 / 4900) loss: 1.846111\n",
      "(Iteration 2401 / 4900) loss: 1.787664\n",
      "(Epoch 5 / 10) train acc: 0.375000; val_acc: 0.384000\n",
      "(Iteration 2501 / 4900) loss: 1.716940\n",
      "(Iteration 2601 / 4900) loss: 1.719435\n",
      "(Iteration 2701 / 4900) loss: 1.630258\n",
      "(Iteration 2801 / 4900) loss: 1.822648\n",
      "(Iteration 2901 / 4900) loss: 1.646183\n",
      "(Epoch 6 / 10) train acc: 0.391000; val_acc: 0.396000\n",
      "(Iteration 3001 / 4900) loss: 1.589831\n",
      "(Iteration 3101 / 4900) loss: 1.557549\n",
      "(Iteration 3201 / 4900) loss: 1.746507\n",
      "(Iteration 3301 / 4900) loss: 1.708489\n",
      "(Iteration 3401 / 4900) loss: 1.706972\n",
      "(Epoch 7 / 10) train acc: 0.380000; val_acc: 0.410000\n",
      "(Iteration 3501 / 4900) loss: 1.625355\n",
      "(Iteration 3601 / 4900) loss: 1.709001\n",
      "(Iteration 3701 / 4900) loss: 1.643320\n",
      "(Iteration 3801 / 4900) loss: 1.493922\n",
      "(Iteration 3901 / 4900) loss: 1.883546\n",
      "(Epoch 8 / 10) train acc: 0.397000; val_acc: 0.421000\n",
      "(Iteration 4001 / 4900) loss: 1.459428\n",
      "(Iteration 4101 / 4900) loss: 1.773788\n",
      "(Iteration 4201 / 4900) loss: 1.617377\n",
      "(Iteration 4301 / 4900) loss: 1.636041\n",
      "(Iteration 4401 / 4900) loss: 1.666267\n",
      "(Epoch 9 / 10) train acc: 0.401000; val_acc: 0.422000\n",
      "(Iteration 4501 / 4900) loss: 1.627411\n",
      "(Iteration 4601 / 4900) loss: 1.703164\n",
      "(Iteration 4701 / 4900) loss: 1.753498\n",
      "(Iteration 4801 / 4900) loss: 1.619654\n",
      "(Epoch 10 / 10) train acc: 0.422000; val_acc: 0.444000\n",
      "80 5e-05 10 0.05\n",
      "Validation accuracy:  0.444\n",
      "(Iteration 1 / 4900) loss: 2.313221\n",
      "(Epoch 0 / 10) train acc: 0.135000; val_acc: 0.121000\n",
      "(Iteration 101 / 4900) loss: 2.300025\n",
      "(Iteration 201 / 4900) loss: 2.234832\n",
      "(Iteration 301 / 4900) loss: 2.217565\n",
      "(Iteration 401 / 4900) loss: 2.167692\n",
      "(Epoch 1 / 10) train acc: 0.241000; val_acc: 0.262000\n",
      "(Iteration 501 / 4900) loss: 2.115021\n",
      "(Iteration 601 / 4900) loss: 2.057496\n",
      "(Iteration 701 / 4900) loss: 2.060887\n",
      "(Iteration 801 / 4900) loss: 2.023761\n",
      "(Iteration 901 / 4900) loss: 1.992129\n",
      "(Epoch 2 / 10) train acc: 0.291000; val_acc: 0.302000\n",
      "(Iteration 1001 / 4900) loss: 2.035591\n",
      "(Iteration 1101 / 4900) loss: 1.908919\n",
      "(Iteration 1201 / 4900) loss: 1.903923\n",
      "(Iteration 1301 / 4900) loss: 1.907643\n",
      "(Iteration 1401 / 4900) loss: 1.842789\n",
      "(Epoch 3 / 10) train acc: 0.306000; val_acc: 0.343000\n",
      "(Iteration 1501 / 4900) loss: 1.928903\n",
      "(Iteration 1601 / 4900) loss: 1.792341\n",
      "(Iteration 1701 / 4900) loss: 1.693428\n",
      "(Iteration 1801 / 4900) loss: 1.819890\n",
      "(Iteration 1901 / 4900) loss: 1.691596\n",
      "(Epoch 4 / 10) train acc: 0.357000; val_acc: 0.364000\n",
      "(Iteration 2001 / 4900) loss: 1.825558\n",
      "(Iteration 2101 / 4900) loss: 1.822816\n",
      "(Iteration 2201 / 4900) loss: 1.756365\n",
      "(Iteration 2301 / 4900) loss: 1.706216\n",
      "(Iteration 2401 / 4900) loss: 1.818448\n",
      "(Epoch 5 / 10) train acc: 0.382000; val_acc: 0.378000\n",
      "(Iteration 2501 / 4900) loss: 1.799587\n",
      "(Iteration 2601 / 4900) loss: 1.773896\n",
      "(Iteration 2701 / 4900) loss: 1.683259\n",
      "(Iteration 2801 / 4900) loss: 1.869435\n",
      "(Iteration 2901 / 4900) loss: 1.748145\n",
      "(Epoch 6 / 10) train acc: 0.406000; val_acc: 0.387000\n",
      "(Iteration 3001 / 4900) loss: 1.756273\n",
      "(Iteration 3101 / 4900) loss: 1.641307\n",
      "(Iteration 3201 / 4900) loss: 1.592654\n",
      "(Iteration 3301 / 4900) loss: 1.594796\n",
      "(Iteration 3401 / 4900) loss: 1.608919\n",
      "(Epoch 7 / 10) train acc: 0.417000; val_acc: 0.398000\n",
      "(Iteration 3501 / 4900) loss: 1.626611\n",
      "(Iteration 3601 / 4900) loss: 1.645039\n",
      "(Iteration 3701 / 4900) loss: 1.700871\n",
      "(Iteration 3801 / 4900) loss: 1.698594\n",
      "(Iteration 3901 / 4900) loss: 1.607593\n",
      "(Epoch 8 / 10) train acc: 0.425000; val_acc: 0.407000\n",
      "(Iteration 4001 / 4900) loss: 1.688897\n",
      "(Iteration 4101 / 4900) loss: 1.665567\n",
      "(Iteration 4201 / 4900) loss: 1.805128\n",
      "(Iteration 4301 / 4900) loss: 1.764520\n",
      "(Iteration 4401 / 4900) loss: 1.835964\n",
      "(Epoch 9 / 10) train acc: 0.397000; val_acc: 0.408000\n",
      "(Iteration 4501 / 4900) loss: 1.659091\n",
      "(Iteration 4601 / 4900) loss: 1.573517\n",
      "(Iteration 4701 / 4900) loss: 1.602481\n",
      "(Iteration 4801 / 4900) loss: 1.574805\n",
      "(Epoch 10 / 10) train acc: 0.418000; val_acc: 0.420000\n",
      "80 5e-05 10 0.1\n",
      "Validation accuracy:  0.42\n",
      "(Iteration 1 / 4900) loss: 2.326860\n",
      "(Epoch 0 / 10) train acc: 0.114000; val_acc: 0.113000\n",
      "(Iteration 101 / 4900) loss: 2.298360\n",
      "(Iteration 201 / 4900) loss: 2.244193\n",
      "(Iteration 301 / 4900) loss: 2.123695\n",
      "(Iteration 401 / 4900) loss: 2.214726\n",
      "(Epoch 1 / 10) train acc: 0.273000; val_acc: 0.273000\n",
      "(Iteration 501 / 4900) loss: 2.097071\n",
      "(Iteration 601 / 4900) loss: 2.070699\n",
      "(Iteration 701 / 4900) loss: 2.074615\n",
      "(Iteration 801 / 4900) loss: 1.976462\n",
      "(Iteration 901 / 4900) loss: 1.935328\n",
      "(Epoch 2 / 10) train acc: 0.310000; val_acc: 0.304000\n",
      "(Iteration 1001 / 4900) loss: 1.892079\n",
      "(Iteration 1101 / 4900) loss: 1.897548\n",
      "(Iteration 1201 / 4900) loss: 1.873012\n",
      "(Iteration 1301 / 4900) loss: 1.967387\n",
      "(Iteration 1401 / 4900) loss: 1.821897\n",
      "(Epoch 3 / 10) train acc: 0.337000; val_acc: 0.341000\n",
      "(Iteration 1501 / 4900) loss: 1.805854\n",
      "(Iteration 1601 / 4900) loss: 1.884766\n",
      "(Iteration 1701 / 4900) loss: 1.939072\n",
      "(Iteration 1801 / 4900) loss: 1.809368\n",
      "(Iteration 1901 / 4900) loss: 1.899627\n",
      "(Epoch 4 / 10) train acc: 0.367000; val_acc: 0.372000\n",
      "(Iteration 2001 / 4900) loss: 1.747542\n",
      "(Iteration 2101 / 4900) loss: 1.907408\n",
      "(Iteration 2201 / 4900) loss: 1.899357\n",
      "(Iteration 2301 / 4900) loss: 1.737765\n",
      "(Iteration 2401 / 4900) loss: 1.744496\n",
      "(Epoch 5 / 10) train acc: 0.375000; val_acc: 0.369000\n",
      "(Iteration 2501 / 4900) loss: 1.946629\n",
      "(Iteration 2601 / 4900) loss: 1.814840\n",
      "(Iteration 2701 / 4900) loss: 1.832205\n",
      "(Iteration 2801 / 4900) loss: 1.687877\n",
      "(Iteration 2901 / 4900) loss: 1.654553\n",
      "(Epoch 6 / 10) train acc: 0.399000; val_acc: 0.389000\n",
      "(Iteration 3001 / 4900) loss: 1.776490\n",
      "(Iteration 3101 / 4900) loss: 1.675405\n",
      "(Iteration 3201 / 4900) loss: 1.708621\n",
      "(Iteration 3301 / 4900) loss: 1.743026\n",
      "(Iteration 3401 / 4900) loss: 1.754573\n",
      "(Epoch 7 / 10) train acc: 0.405000; val_acc: 0.396000\n",
      "(Iteration 3501 / 4900) loss: 1.661538\n",
      "(Iteration 3601 / 4900) loss: 1.766982\n",
      "(Iteration 3701 / 4900) loss: 1.706259\n",
      "(Iteration 3801 / 4900) loss: 1.847859\n",
      "(Iteration 3901 / 4900) loss: 1.737539\n",
      "(Epoch 8 / 10) train acc: 0.394000; val_acc: 0.416000\n",
      "(Iteration 4001 / 4900) loss: 1.694812\n",
      "(Iteration 4101 / 4900) loss: 1.740240\n",
      "(Iteration 4201 / 4900) loss: 1.595032\n",
      "(Iteration 4301 / 4900) loss: 1.571586\n",
      "(Iteration 4401 / 4900) loss: 1.730245\n",
      "(Epoch 9 / 10) train acc: 0.419000; val_acc: 0.416000\n",
      "(Iteration 4501 / 4900) loss: 1.680794\n",
      "(Iteration 4601 / 4900) loss: 1.792916\n",
      "(Iteration 4701 / 4900) loss: 1.652870\n",
      "(Iteration 4801 / 4900) loss: 1.618322\n",
      "(Epoch 10 / 10) train acc: 0.460000; val_acc: 0.436000\n",
      "80 5e-05 10 0.2\n",
      "Validation accuracy:  0.436\n",
      "(Iteration 1 / 4900) loss: 2.311148\n",
      "(Epoch 0 / 10) train acc: 0.086000; val_acc: 0.099000\n",
      "(Iteration 101 / 4900) loss: 2.276200\n",
      "(Iteration 201 / 4900) loss: 2.246294\n",
      "(Iteration 301 / 4900) loss: 2.167956\n",
      "(Iteration 401 / 4900) loss: 2.137056\n",
      "(Epoch 1 / 10) train acc: 0.275000; val_acc: 0.270000\n",
      "(Iteration 501 / 4900) loss: 2.069227\n",
      "(Iteration 601 / 4900) loss: 2.032496\n",
      "(Iteration 701 / 4900) loss: 2.043810\n",
      "(Iteration 801 / 4900) loss: 1.981112\n",
      "(Iteration 901 / 4900) loss: 1.970868\n",
      "(Epoch 2 / 10) train acc: 0.317000; val_acc: 0.330000\n",
      "(Iteration 1001 / 4900) loss: 1.934992\n",
      "(Iteration 1101 / 4900) loss: 1.887619\n",
      "(Iteration 1201 / 4900) loss: 1.903812\n",
      "(Iteration 1301 / 4900) loss: 1.914022\n",
      "(Iteration 1401 / 4900) loss: 1.791144\n",
      "(Epoch 3 / 10) train acc: 0.356000; val_acc: 0.352000\n",
      "(Iteration 1501 / 4900) loss: 1.861155\n",
      "(Iteration 1601 / 4900) loss: 1.769681\n",
      "(Iteration 1701 / 4900) loss: 1.688084\n",
      "(Iteration 1801 / 4900) loss: 1.807475\n",
      "(Iteration 1901 / 4900) loss: 1.862304\n",
      "(Epoch 4 / 10) train acc: 0.373000; val_acc: 0.370000\n",
      "(Iteration 2001 / 4900) loss: 1.860036\n",
      "(Iteration 2101 / 4900) loss: 1.660054\n",
      "(Iteration 2201 / 4900) loss: 1.737921\n",
      "(Iteration 2301 / 4900) loss: 1.727737\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 2401 / 4900) loss: 1.793978\n",
      "(Epoch 5 / 10) train acc: 0.360000; val_acc: 0.393000\n",
      "(Iteration 2501 / 4900) loss: 1.602071\n",
      "(Iteration 2601 / 4900) loss: 1.689660\n",
      "(Iteration 2701 / 4900) loss: 1.829213\n",
      "(Iteration 2801 / 4900) loss: 1.641319\n",
      "(Iteration 2901 / 4900) loss: 1.846710\n",
      "(Epoch 6 / 10) train acc: 0.378000; val_acc: 0.400000\n",
      "(Iteration 3001 / 4900) loss: 1.702112\n",
      "(Iteration 3101 / 4900) loss: 1.871871\n",
      "(Iteration 3201 / 4900) loss: 1.653786\n",
      "(Iteration 3301 / 4900) loss: 1.628197\n",
      "(Iteration 3401 / 4900) loss: 1.739046\n",
      "(Epoch 7 / 10) train acc: 0.404000; val_acc: 0.404000\n",
      "(Iteration 3501 / 4900) loss: 1.766504\n",
      "(Iteration 3601 / 4900) loss: 1.781798\n",
      "(Iteration 3701 / 4900) loss: 1.633402\n",
      "(Iteration 3801 / 4900) loss: 1.609628\n",
      "(Iteration 3901 / 4900) loss: 1.735974\n",
      "(Epoch 8 / 10) train acc: 0.386000; val_acc: 0.416000\n",
      "(Iteration 4001 / 4900) loss: 1.591613\n",
      "(Iteration 4101 / 4900) loss: 1.612282\n",
      "(Iteration 4201 / 4900) loss: 1.677841\n",
      "(Iteration 4301 / 4900) loss: 1.661040\n",
      "(Iteration 4401 / 4900) loss: 1.649782\n",
      "(Epoch 9 / 10) train acc: 0.388000; val_acc: 0.433000\n",
      "(Iteration 4501 / 4900) loss: 1.786090\n",
      "(Iteration 4601 / 4900) loss: 1.590221\n",
      "(Iteration 4701 / 4900) loss: 1.550210\n",
      "(Iteration 4801 / 4900) loss: 1.665795\n",
      "(Epoch 10 / 10) train acc: 0.443000; val_acc: 0.437000\n",
      "100 5e-05 10 0.05\n",
      "Validation accuracy:  0.437\n",
      "(Iteration 1 / 4900) loss: 2.318287\n",
      "(Epoch 0 / 10) train acc: 0.121000; val_acc: 0.107000\n",
      "(Iteration 101 / 4900) loss: 2.296339\n",
      "(Iteration 201 / 4900) loss: 2.224584\n",
      "(Iteration 301 / 4900) loss: 2.202494\n",
      "(Iteration 401 / 4900) loss: 2.125326\n",
      "(Epoch 1 / 10) train acc: 0.286000; val_acc: 0.285000\n",
      "(Iteration 501 / 4900) loss: 2.063728\n",
      "(Iteration 601 / 4900) loss: 1.997697\n",
      "(Iteration 701 / 4900) loss: 2.113524\n",
      "(Iteration 801 / 4900) loss: 2.010309\n",
      "(Iteration 901 / 4900) loss: 2.035046\n",
      "(Epoch 2 / 10) train acc: 0.306000; val_acc: 0.321000\n",
      "(Iteration 1001 / 4900) loss: 1.936037\n",
      "(Iteration 1101 / 4900) loss: 1.909044\n",
      "(Iteration 1201 / 4900) loss: 1.815215\n",
      "(Iteration 1301 / 4900) loss: 1.956071\n",
      "(Iteration 1401 / 4900) loss: 1.952536\n",
      "(Epoch 3 / 10) train acc: 0.341000; val_acc: 0.352000\n",
      "(Iteration 1501 / 4900) loss: 1.802469\n",
      "(Iteration 1601 / 4900) loss: 1.985304\n",
      "(Iteration 1701 / 4900) loss: 1.886807\n",
      "(Iteration 1801 / 4900) loss: 1.701470\n",
      "(Iteration 1901 / 4900) loss: 1.791414\n",
      "(Epoch 4 / 10) train acc: 0.378000; val_acc: 0.375000\n",
      "(Iteration 2001 / 4900) loss: 1.755186\n",
      "(Iteration 2101 / 4900) loss: 1.783132\n",
      "(Iteration 2201 / 4900) loss: 1.888622\n",
      "(Iteration 2301 / 4900) loss: 1.765124\n",
      "(Iteration 2401 / 4900) loss: 1.793913\n",
      "(Epoch 5 / 10) train acc: 0.360000; val_acc: 0.383000\n",
      "(Iteration 2501 / 4900) loss: 1.755230\n",
      "(Iteration 2601 / 4900) loss: 1.710048\n",
      "(Iteration 2701 / 4900) loss: 1.835827\n",
      "(Iteration 2801 / 4900) loss: 1.864652\n",
      "(Iteration 2901 / 4900) loss: 1.739879\n",
      "(Epoch 6 / 10) train acc: 0.398000; val_acc: 0.391000\n",
      "(Iteration 3001 / 4900) loss: 1.632204\n",
      "(Iteration 3101 / 4900) loss: 1.843573\n",
      "(Iteration 3201 / 4900) loss: 1.809045\n",
      "(Iteration 3301 / 4900) loss: 1.695528\n",
      "(Iteration 3401 / 4900) loss: 1.850887\n",
      "(Epoch 7 / 10) train acc: 0.389000; val_acc: 0.407000\n",
      "(Iteration 3501 / 4900) loss: 1.713002\n",
      "(Iteration 3601 / 4900) loss: 1.782536\n",
      "(Iteration 3701 / 4900) loss: 1.833115\n",
      "(Iteration 3801 / 4900) loss: 1.603257\n",
      "(Iteration 3901 / 4900) loss: 1.747157\n",
      "(Epoch 8 / 10) train acc: 0.421000; val_acc: 0.416000\n",
      "(Iteration 4001 / 4900) loss: 1.794800\n",
      "(Iteration 4101 / 4900) loss: 1.751227\n",
      "(Iteration 4201 / 4900) loss: 1.600239\n",
      "(Iteration 4301 / 4900) loss: 1.911713\n",
      "(Iteration 4401 / 4900) loss: 1.818405\n",
      "(Epoch 9 / 10) train acc: 0.431000; val_acc: 0.424000\n",
      "(Iteration 4501 / 4900) loss: 1.698222\n",
      "(Iteration 4601 / 4900) loss: 1.783606\n",
      "(Iteration 4701 / 4900) loss: 1.721544\n",
      "(Iteration 4801 / 4900) loss: 1.596185\n",
      "(Epoch 10 / 10) train acc: 0.433000; val_acc: 0.435000\n",
      "100 5e-05 10 0.1\n",
      "Validation accuracy:  0.435\n",
      "(Iteration 1 / 4900) loss: 2.333530\n",
      "(Epoch 0 / 10) train acc: 0.113000; val_acc: 0.095000\n",
      "(Iteration 101 / 4900) loss: 2.307379\n",
      "(Iteration 201 / 4900) loss: 2.255167\n",
      "(Iteration 301 / 4900) loss: 2.170576\n",
      "(Iteration 401 / 4900) loss: 2.109915\n",
      "(Epoch 1 / 10) train acc: 0.262000; val_acc: 0.274000\n",
      "(Iteration 501 / 4900) loss: 2.134499\n",
      "(Iteration 601 / 4900) loss: 1.993084\n",
      "(Iteration 701 / 4900) loss: 2.090837\n",
      "(Iteration 801 / 4900) loss: 2.059828\n",
      "(Iteration 901 / 4900) loss: 1.861980\n",
      "(Epoch 2 / 10) train acc: 0.310000; val_acc: 0.317000\n",
      "(Iteration 1001 / 4900) loss: 1.870134\n",
      "(Iteration 1101 / 4900) loss: 1.922861\n",
      "(Iteration 1201 / 4900) loss: 1.972793\n",
      "(Iteration 1301 / 4900) loss: 1.941400\n",
      "(Iteration 1401 / 4900) loss: 1.922806\n",
      "(Epoch 3 / 10) train acc: 0.317000; val_acc: 0.341000\n",
      "(Iteration 1501 / 4900) loss: 1.750415\n",
      "(Iteration 1601 / 4900) loss: 1.961803\n",
      "(Iteration 1701 / 4900) loss: 1.811913\n",
      "(Iteration 1801 / 4900) loss: 1.907477\n",
      "(Iteration 1901 / 4900) loss: 1.952416\n",
      "(Epoch 4 / 10) train acc: 0.363000; val_acc: 0.369000\n",
      "(Iteration 2001 / 4900) loss: 1.990786\n",
      "(Iteration 2101 / 4900) loss: 1.798566\n",
      "(Iteration 2201 / 4900) loss: 1.864485\n",
      "(Iteration 2301 / 4900) loss: 1.743385\n",
      "(Iteration 2401 / 4900) loss: 1.627095\n",
      "(Epoch 5 / 10) train acc: 0.371000; val_acc: 0.377000\n",
      "(Iteration 2501 / 4900) loss: 1.764015\n",
      "(Iteration 2601 / 4900) loss: 1.908942\n",
      "(Iteration 2701 / 4900) loss: 1.836395\n",
      "(Iteration 2801 / 4900) loss: 1.826540\n",
      "(Iteration 2901 / 4900) loss: 1.694893\n",
      "(Epoch 6 / 10) train acc: 0.387000; val_acc: 0.396000\n",
      "(Iteration 3001 / 4900) loss: 1.711471\n",
      "(Iteration 3101 / 4900) loss: 1.650826\n",
      "(Iteration 3201 / 4900) loss: 1.801041\n",
      "(Iteration 3301 / 4900) loss: 1.755321\n",
      "(Iteration 3401 / 4900) loss: 1.812225\n",
      "(Epoch 7 / 10) train acc: 0.382000; val_acc: 0.402000\n",
      "(Iteration 3501 / 4900) loss: 1.660270\n",
      "(Iteration 3601 / 4900) loss: 1.632357\n",
      "(Iteration 3701 / 4900) loss: 1.749842\n",
      "(Iteration 3801 / 4900) loss: 1.526692\n",
      "(Iteration 3901 / 4900) loss: 1.703316\n",
      "(Epoch 8 / 10) train acc: 0.404000; val_acc: 0.409000\n",
      "(Iteration 4001 / 4900) loss: 1.690161\n",
      "(Iteration 4101 / 4900) loss: 1.582925\n",
      "(Iteration 4201 / 4900) loss: 1.736427\n",
      "(Iteration 4301 / 4900) loss: 1.688338\n",
      "(Iteration 4401 / 4900) loss: 1.679554\n",
      "(Epoch 9 / 10) train acc: 0.404000; val_acc: 0.412000\n",
      "(Iteration 4501 / 4900) loss: 1.568464\n",
      "(Iteration 4601 / 4900) loss: 1.681712\n",
      "(Iteration 4701 / 4900) loss: 1.693644\n",
      "(Iteration 4801 / 4900) loss: 1.756096\n",
      "(Epoch 10 / 10) train acc: 0.452000; val_acc: 0.432000\n",
      "100 5e-05 10 0.2\n",
      "Validation accuracy:  0.432\n",
      "(Iteration 1 / 4900) loss: 2.308050\n",
      "(Epoch 0 / 10) train acc: 0.093000; val_acc: 0.087000\n",
      "(Iteration 101 / 4900) loss: 2.275291\n",
      "(Iteration 201 / 4900) loss: 2.142375\n",
      "(Iteration 301 / 4900) loss: 1.992222\n",
      "(Iteration 401 / 4900) loss: 2.014521\n",
      "(Epoch 1 / 10) train acc: 0.282000; val_acc: 0.285000\n",
      "(Iteration 501 / 4900) loss: 1.977041\n",
      "(Iteration 601 / 4900) loss: 1.882158\n",
      "(Iteration 701 / 4900) loss: 2.024855\n",
      "(Iteration 801 / 4900) loss: 1.835531\n",
      "(Iteration 901 / 4900) loss: 1.989568\n",
      "(Epoch 2 / 10) train acc: 0.372000; val_acc: 0.343000\n",
      "(Iteration 1001 / 4900) loss: 1.799237\n",
      "(Iteration 1101 / 4900) loss: 1.730601\n",
      "(Iteration 1201 / 4900) loss: 1.749707\n",
      "(Iteration 1301 / 4900) loss: 1.756691\n",
      "(Iteration 1401 / 4900) loss: 1.733801\n",
      "(Epoch 3 / 10) train acc: 0.392000; val_acc: 0.387000\n",
      "(Iteration 1501 / 4900) loss: 1.667731\n",
      "(Iteration 1601 / 4900) loss: 1.731510\n",
      "(Iteration 1701 / 4900) loss: 1.712473\n",
      "(Iteration 1801 / 4900) loss: 1.619923\n",
      "(Iteration 1901 / 4900) loss: 1.788536\n",
      "(Epoch 4 / 10) train acc: 0.392000; val_acc: 0.414000\n",
      "(Iteration 2001 / 4900) loss: 1.706289\n",
      "(Iteration 2101 / 4900) loss: 1.654068\n",
      "(Iteration 2201 / 4900) loss: 1.683985\n",
      "(Iteration 2301 / 4900) loss: 1.705260\n",
      "(Iteration 2401 / 4900) loss: 1.585417\n",
      "(Epoch 5 / 10) train acc: 0.410000; val_acc: 0.421000\n",
      "(Iteration 2501 / 4900) loss: 1.768793\n",
      "(Iteration 2601 / 4900) loss: 1.673144\n",
      "(Iteration 2701 / 4900) loss: 1.641528\n",
      "(Iteration 2801 / 4900) loss: 1.593295\n",
      "(Iteration 2901 / 4900) loss: 1.322831\n",
      "(Epoch 6 / 10) train acc: 0.431000; val_acc: 0.437000\n",
      "(Iteration 3001 / 4900) loss: 1.663135\n",
      "(Iteration 3101 / 4900) loss: 1.551300\n",
      "(Iteration 3201 / 4900) loss: 1.512846\n",
      "(Iteration 3301 / 4900) loss: 1.619172\n",
      "(Iteration 3401 / 4900) loss: 1.478870\n",
      "(Epoch 7 / 10) train acc: 0.462000; val_acc: 0.453000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 3501 / 4900) loss: 1.630085\n",
      "(Iteration 3601 / 4900) loss: 1.503188\n",
      "(Iteration 3701 / 4900) loss: 1.483018\n",
      "(Iteration 3801 / 4900) loss: 1.516442\n",
      "(Iteration 3901 / 4900) loss: 1.381855\n",
      "(Epoch 8 / 10) train acc: 0.467000; val_acc: 0.455000\n",
      "(Iteration 4001 / 4900) loss: 1.647396\n",
      "(Iteration 4101 / 4900) loss: 1.566677\n",
      "(Iteration 4201 / 4900) loss: 1.689654\n",
      "(Iteration 4301 / 4900) loss: 1.499065\n",
      "(Iteration 4401 / 4900) loss: 1.531377\n",
      "(Epoch 9 / 10) train acc: 0.503000; val_acc: 0.469000\n",
      "(Iteration 4501 / 4900) loss: 1.390360\n",
      "(Iteration 4601 / 4900) loss: 1.327946\n",
      "(Iteration 4701 / 4900) loss: 1.502736\n",
      "(Iteration 4801 / 4900) loss: 1.619453\n",
      "(Epoch 10 / 10) train acc: 0.451000; val_acc: 0.471000\n",
      "50 0.0001 10 0.05\n",
      "Validation accuracy:  0.471\n",
      "(Iteration 1 / 4900) loss: 2.310702\n",
      "(Epoch 0 / 10) train acc: 0.116000; val_acc: 0.116000\n",
      "(Iteration 101 / 4900) loss: 2.280294\n",
      "(Iteration 201 / 4900) loss: 2.128165\n",
      "(Iteration 301 / 4900) loss: 2.084947\n",
      "(Iteration 401 / 4900) loss: 2.005894\n",
      "(Epoch 1 / 10) train acc: 0.315000; val_acc: 0.298000\n",
      "(Iteration 501 / 4900) loss: 1.864644\n",
      "(Iteration 601 / 4900) loss: 1.981393\n",
      "(Iteration 701 / 4900) loss: 1.898578\n",
      "(Iteration 801 / 4900) loss: 1.807448\n",
      "(Iteration 901 / 4900) loss: 1.968967\n",
      "(Epoch 2 / 10) train acc: 0.365000; val_acc: 0.364000\n",
      "(Iteration 1001 / 4900) loss: 1.812569\n",
      "(Iteration 1101 / 4900) loss: 1.817338\n",
      "(Iteration 1201 / 4900) loss: 1.671679\n",
      "(Iteration 1301 / 4900) loss: 1.847686\n",
      "(Iteration 1401 / 4900) loss: 1.844131\n",
      "(Epoch 3 / 10) train acc: 0.394000; val_acc: 0.394000\n",
      "(Iteration 1501 / 4900) loss: 1.714882\n",
      "(Iteration 1601 / 4900) loss: 1.646856\n",
      "(Iteration 1701 / 4900) loss: 1.603033\n",
      "(Iteration 1801 / 4900) loss: 1.808248\n",
      "(Iteration 1901 / 4900) loss: 1.542678\n",
      "(Epoch 4 / 10) train acc: 0.435000; val_acc: 0.417000\n",
      "(Iteration 2001 / 4900) loss: 1.807891\n",
      "(Iteration 2101 / 4900) loss: 1.684389\n",
      "(Iteration 2201 / 4900) loss: 1.832145\n",
      "(Iteration 2301 / 4900) loss: 1.662894\n",
      "(Iteration 2401 / 4900) loss: 1.691416\n",
      "(Epoch 5 / 10) train acc: 0.427000; val_acc: 0.434000\n",
      "(Iteration 2501 / 4900) loss: 1.670000\n",
      "(Iteration 2601 / 4900) loss: 1.621885\n",
      "(Iteration 2701 / 4900) loss: 1.708511\n",
      "(Iteration 2801 / 4900) loss: 1.515929\n",
      "(Iteration 2901 / 4900) loss: 1.355567\n",
      "(Epoch 6 / 10) train acc: 0.438000; val_acc: 0.439000\n",
      "(Iteration 3001 / 4900) loss: 1.711952\n",
      "(Iteration 3101 / 4900) loss: 1.544360\n",
      "(Iteration 3201 / 4900) loss: 1.571813\n",
      "(Iteration 3301 / 4900) loss: 1.323453\n",
      "(Iteration 3401 / 4900) loss: 1.601348\n",
      "(Epoch 7 / 10) train acc: 0.446000; val_acc: 0.443000\n",
      "(Iteration 3501 / 4900) loss: 1.793854\n",
      "(Iteration 3601 / 4900) loss: 1.561467\n",
      "(Iteration 3701 / 4900) loss: 1.521760\n",
      "(Iteration 3801 / 4900) loss: 1.604358\n",
      "(Iteration 3901 / 4900) loss: 1.685632\n",
      "(Epoch 8 / 10) train acc: 0.417000; val_acc: 0.454000\n",
      "(Iteration 4001 / 4900) loss: 1.698863\n",
      "(Iteration 4101 / 4900) loss: 1.544066\n",
      "(Iteration 4201 / 4900) loss: 1.626640\n",
      "(Iteration 4301 / 4900) loss: 1.441963\n",
      "(Iteration 4401 / 4900) loss: 1.501296\n",
      "(Epoch 9 / 10) train acc: 0.432000; val_acc: 0.455000\n",
      "(Iteration 4501 / 4900) loss: 1.365669\n",
      "(Iteration 4601 / 4900) loss: 1.605813\n",
      "(Iteration 4701 / 4900) loss: 1.626326\n",
      "(Iteration 4801 / 4900) loss: 1.411006\n",
      "(Epoch 10 / 10) train acc: 0.471000; val_acc: 0.473000\n",
      "50 0.0001 10 0.1\n",
      "Validation accuracy:  0.473\n",
      "(Iteration 1 / 4900) loss: 2.316958\n",
      "(Epoch 0 / 10) train acc: 0.113000; val_acc: 0.132000\n",
      "(Iteration 101 / 4900) loss: 2.281439\n",
      "(Iteration 201 / 4900) loss: 2.136171\n",
      "(Iteration 301 / 4900) loss: 2.144645\n",
      "(Iteration 401 / 4900) loss: 2.166517\n",
      "(Epoch 1 / 10) train acc: 0.297000; val_acc: 0.296000\n",
      "(Iteration 501 / 4900) loss: 2.021169\n",
      "(Iteration 601 / 4900) loss: 1.869978\n",
      "(Iteration 701 / 4900) loss: 1.845738\n",
      "(Iteration 801 / 4900) loss: 1.809903\n",
      "(Iteration 901 / 4900) loss: 1.811042\n",
      "(Epoch 2 / 10) train acc: 0.347000; val_acc: 0.365000\n",
      "(Iteration 1001 / 4900) loss: 1.815853\n",
      "(Iteration 1101 / 4900) loss: 1.703410\n",
      "(Iteration 1201 / 4900) loss: 1.739202\n",
      "(Iteration 1301 / 4900) loss: 1.755771\n",
      "(Iteration 1401 / 4900) loss: 1.777016\n",
      "(Epoch 3 / 10) train acc: 0.367000; val_acc: 0.385000\n",
      "(Iteration 1501 / 4900) loss: 1.753875\n",
      "(Iteration 1601 / 4900) loss: 1.632705\n",
      "(Iteration 1701 / 4900) loss: 1.660241\n",
      "(Iteration 1801 / 4900) loss: 1.710532\n",
      "(Iteration 1901 / 4900) loss: 1.663507\n",
      "(Epoch 4 / 10) train acc: 0.418000; val_acc: 0.416000\n",
      "(Iteration 2001 / 4900) loss: 1.709915\n",
      "(Iteration 2101 / 4900) loss: 1.757130\n",
      "(Iteration 2201 / 4900) loss: 1.703823\n",
      "(Iteration 2301 / 4900) loss: 1.761471\n",
      "(Iteration 2401 / 4900) loss: 1.706301\n",
      "(Epoch 5 / 10) train acc: 0.428000; val_acc: 0.428000\n",
      "(Iteration 2501 / 4900) loss: 1.957256\n",
      "(Iteration 2601 / 4900) loss: 1.745810\n",
      "(Iteration 2701 / 4900) loss: 1.684788\n",
      "(Iteration 2801 / 4900) loss: 1.761713\n",
      "(Iteration 2901 / 4900) loss: 1.655531\n",
      "(Epoch 6 / 10) train acc: 0.420000; val_acc: 0.442000\n",
      "(Iteration 3001 / 4900) loss: 1.592902\n",
      "(Iteration 3101 / 4900) loss: 1.471635\n",
      "(Iteration 3201 / 4900) loss: 1.568666\n",
      "(Iteration 3301 / 4900) loss: 1.657244\n",
      "(Iteration 3401 / 4900) loss: 1.475793\n",
      "(Epoch 7 / 10) train acc: 0.434000; val_acc: 0.462000\n",
      "(Iteration 3501 / 4900) loss: 1.655185\n",
      "(Iteration 3601 / 4900) loss: 1.476533\n",
      "(Iteration 3701 / 4900) loss: 1.603258\n",
      "(Iteration 3801 / 4900) loss: 1.652358\n",
      "(Iteration 3901 / 4900) loss: 1.688153\n",
      "(Epoch 8 / 10) train acc: 0.455000; val_acc: 0.462000\n",
      "(Iteration 4001 / 4900) loss: 1.514241\n",
      "(Iteration 4101 / 4900) loss: 1.616417\n",
      "(Iteration 4201 / 4900) loss: 1.662732\n",
      "(Iteration 4301 / 4900) loss: 1.472341\n",
      "(Iteration 4401 / 4900) loss: 1.589012\n",
      "(Epoch 9 / 10) train acc: 0.431000; val_acc: 0.471000\n",
      "(Iteration 4501 / 4900) loss: 1.688631\n",
      "(Iteration 4601 / 4900) loss: 1.620366\n",
      "(Iteration 4701 / 4900) loss: 1.669959\n",
      "(Iteration 4801 / 4900) loss: 1.608284\n",
      "(Epoch 10 / 10) train acc: 0.495000; val_acc: 0.484000\n",
      "50 0.0001 10 0.2\n",
      "Validation accuracy:  0.484\n",
      "(Iteration 1 / 4900) loss: 2.305917\n",
      "(Epoch 0 / 10) train acc: 0.088000; val_acc: 0.099000\n",
      "(Iteration 101 / 4900) loss: 2.255386\n",
      "(Iteration 201 / 4900) loss: 2.143900\n",
      "(Iteration 301 / 4900) loss: 2.020554\n",
      "(Iteration 401 / 4900) loss: 1.898710\n",
      "(Epoch 1 / 10) train acc: 0.301000; val_acc: 0.314000\n",
      "(Iteration 501 / 4900) loss: 1.904505\n",
      "(Iteration 601 / 4900) loss: 1.921591\n",
      "(Iteration 701 / 4900) loss: 1.769415\n",
      "(Iteration 801 / 4900) loss: 1.933094\n",
      "(Iteration 901 / 4900) loss: 1.805227\n",
      "(Epoch 2 / 10) train acc: 0.372000; val_acc: 0.371000\n",
      "(Iteration 1001 / 4900) loss: 1.891736\n",
      "(Iteration 1101 / 4900) loss: 1.825663\n",
      "(Iteration 1201 / 4900) loss: 1.803279\n",
      "(Iteration 1301 / 4900) loss: 1.792100\n",
      "(Iteration 1401 / 4900) loss: 1.772515\n",
      "(Epoch 3 / 10) train acc: 0.380000; val_acc: 0.394000\n",
      "(Iteration 1501 / 4900) loss: 1.771900\n",
      "(Iteration 1601 / 4900) loss: 1.730604\n",
      "(Iteration 1701 / 4900) loss: 1.802458\n",
      "(Iteration 1801 / 4900) loss: 1.538618\n",
      "(Iteration 1901 / 4900) loss: 1.508725\n",
      "(Epoch 4 / 10) train acc: 0.439000; val_acc: 0.416000\n",
      "(Iteration 2001 / 4900) loss: 1.918034\n",
      "(Iteration 2101 / 4900) loss: 1.799393\n",
      "(Iteration 2201 / 4900) loss: 1.554932\n",
      "(Iteration 2301 / 4900) loss: 1.830074\n",
      "(Iteration 2401 / 4900) loss: 1.645574\n",
      "(Epoch 5 / 10) train acc: 0.419000; val_acc: 0.449000\n",
      "(Iteration 2501 / 4900) loss: 1.615698\n",
      "(Iteration 2601 / 4900) loss: 1.506363\n",
      "(Iteration 2701 / 4900) loss: 1.698066\n",
      "(Iteration 2801 / 4900) loss: 1.637132\n",
      "(Iteration 2901 / 4900) loss: 1.605030\n",
      "(Epoch 6 / 10) train acc: 0.425000; val_acc: 0.463000\n",
      "(Iteration 3001 / 4900) loss: 1.624340\n",
      "(Iteration 3101 / 4900) loss: 1.545534\n",
      "(Iteration 3201 / 4900) loss: 1.603668\n",
      "(Iteration 3301 / 4900) loss: 1.435537\n",
      "(Iteration 3401 / 4900) loss: 1.644675\n",
      "(Epoch 7 / 10) train acc: 0.455000; val_acc: 0.465000\n",
      "(Iteration 3501 / 4900) loss: 1.480377\n",
      "(Iteration 3601 / 4900) loss: 1.469642\n",
      "(Iteration 3701 / 4900) loss: 1.637513\n",
      "(Iteration 3801 / 4900) loss: 1.621422\n",
      "(Iteration 3901 / 4900) loss: 1.531045\n",
      "(Epoch 8 / 10) train acc: 0.447000; val_acc: 0.462000\n",
      "(Iteration 4001 / 4900) loss: 1.398881\n",
      "(Iteration 4101 / 4900) loss: 1.555159\n",
      "(Iteration 4201 / 4900) loss: 1.492939\n",
      "(Iteration 4301 / 4900) loss: 1.509978\n",
      "(Iteration 4401 / 4900) loss: 1.483432\n",
      "(Epoch 9 / 10) train acc: 0.493000; val_acc: 0.468000\n",
      "(Iteration 4501 / 4900) loss: 1.569098\n",
      "(Iteration 4601 / 4900) loss: 1.556050\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 4701 / 4900) loss: 1.396090\n",
      "(Iteration 4801 / 4900) loss: 1.282797\n",
      "(Epoch 10 / 10) train acc: 0.434000; val_acc: 0.459000\n",
      "80 0.0001 10 0.05\n",
      "Validation accuracy:  0.468\n",
      "(Iteration 1 / 4900) loss: 2.315408\n",
      "(Epoch 0 / 10) train acc: 0.113000; val_acc: 0.099000\n",
      "(Iteration 101 / 4900) loss: 2.264005\n",
      "(Iteration 201 / 4900) loss: 2.176036\n",
      "(Iteration 301 / 4900) loss: 2.002390\n",
      "(Iteration 401 / 4900) loss: 1.978130\n",
      "(Epoch 1 / 10) train acc: 0.316000; val_acc: 0.308000\n",
      "(Iteration 501 / 4900) loss: 1.969739\n",
      "(Iteration 601 / 4900) loss: 1.831500\n",
      "(Iteration 701 / 4900) loss: 1.953330\n",
      "(Iteration 801 / 4900) loss: 1.912121\n",
      "(Iteration 901 / 4900) loss: 1.734908\n",
      "(Epoch 2 / 10) train acc: 0.365000; val_acc: 0.363000\n",
      "(Iteration 1001 / 4900) loss: 1.832057\n",
      "(Iteration 1101 / 4900) loss: 1.851627\n",
      "(Iteration 1201 / 4900) loss: 1.740286\n",
      "(Iteration 1301 / 4900) loss: 1.592603\n",
      "(Iteration 1401 / 4900) loss: 1.711082\n",
      "(Epoch 3 / 10) train acc: 0.422000; val_acc: 0.396000\n",
      "(Iteration 1501 / 4900) loss: 1.705503\n",
      "(Iteration 1601 / 4900) loss: 1.656964\n",
      "(Iteration 1701 / 4900) loss: 1.752617\n",
      "(Iteration 1801 / 4900) loss: 1.811035\n",
      "(Iteration 1901 / 4900) loss: 1.873905\n",
      "(Epoch 4 / 10) train acc: 0.432000; val_acc: 0.427000\n",
      "(Iteration 2001 / 4900) loss: 1.669607\n",
      "(Iteration 2101 / 4900) loss: 1.633073\n",
      "(Iteration 2201 / 4900) loss: 1.629457\n",
      "(Iteration 2301 / 4900) loss: 1.629079\n",
      "(Iteration 2401 / 4900) loss: 1.619721\n",
      "(Epoch 5 / 10) train acc: 0.424000; val_acc: 0.450000\n",
      "(Iteration 2501 / 4900) loss: 1.653115\n",
      "(Iteration 2601 / 4900) loss: 1.703578\n",
      "(Iteration 2701 / 4900) loss: 1.596709\n",
      "(Iteration 2801 / 4900) loss: 1.602829\n",
      "(Iteration 2901 / 4900) loss: 1.659944\n",
      "(Epoch 6 / 10) train acc: 0.446000; val_acc: 0.455000\n",
      "(Iteration 3001 / 4900) loss: 1.505717\n",
      "(Iteration 3101 / 4900) loss: 1.640329\n",
      "(Iteration 3201 / 4900) loss: 1.609468\n",
      "(Iteration 3301 / 4900) loss: 1.537805\n",
      "(Iteration 3401 / 4900) loss: 1.383710\n",
      "(Epoch 7 / 10) train acc: 0.446000; val_acc: 0.473000\n",
      "(Iteration 3501 / 4900) loss: 1.576315\n",
      "(Iteration 3601 / 4900) loss: 1.517669\n",
      "(Iteration 3701 / 4900) loss: 1.536040\n",
      "(Iteration 3801 / 4900) loss: 1.521780\n",
      "(Iteration 3901 / 4900) loss: 1.614461\n",
      "(Epoch 8 / 10) train acc: 0.459000; val_acc: 0.454000\n",
      "(Iteration 4001 / 4900) loss: 1.474957\n",
      "(Iteration 4101 / 4900) loss: 1.454080\n",
      "(Iteration 4201 / 4900) loss: 1.634476\n",
      "(Iteration 4301 / 4900) loss: 1.442444\n",
      "(Iteration 4401 / 4900) loss: 1.497563\n",
      "(Epoch 9 / 10) train acc: 0.458000; val_acc: 0.464000\n",
      "(Iteration 4501 / 4900) loss: 1.429922\n",
      "(Iteration 4601 / 4900) loss: 1.522047\n",
      "(Iteration 4701 / 4900) loss: 1.499663\n",
      "(Iteration 4801 / 4900) loss: 1.601330\n",
      "(Epoch 10 / 10) train acc: 0.453000; val_acc: 0.482000\n",
      "80 0.0001 10 0.1\n",
      "Validation accuracy:  0.482\n",
      "(Iteration 1 / 4900) loss: 2.326316\n",
      "(Epoch 0 / 10) train acc: 0.115000; val_acc: 0.119000\n",
      "(Iteration 101 / 4900) loss: 2.281928\n",
      "(Iteration 201 / 4900) loss: 2.198623\n",
      "(Iteration 301 / 4900) loss: 2.066208\n",
      "(Iteration 401 / 4900) loss: 2.070084\n",
      "(Epoch 1 / 10) train acc: 0.327000; val_acc: 0.315000\n",
      "(Iteration 501 / 4900) loss: 1.944324\n",
      "(Iteration 601 / 4900) loss: 2.024030\n",
      "(Iteration 701 / 4900) loss: 1.834323\n",
      "(Iteration 801 / 4900) loss: 1.858632\n",
      "(Iteration 901 / 4900) loss: 1.719136\n",
      "(Epoch 2 / 10) train acc: 0.373000; val_acc: 0.369000\n",
      "(Iteration 1001 / 4900) loss: 1.800750\n",
      "(Iteration 1101 / 4900) loss: 1.894474\n",
      "(Iteration 1201 / 4900) loss: 1.701221\n",
      "(Iteration 1301 / 4900) loss: 1.832175\n",
      "(Iteration 1401 / 4900) loss: 1.783761\n",
      "(Epoch 3 / 10) train acc: 0.397000; val_acc: 0.392000\n",
      "(Iteration 1501 / 4900) loss: 1.886906\n",
      "(Iteration 1601 / 4900) loss: 1.843775\n",
      "(Iteration 1701 / 4900) loss: 1.751613\n",
      "(Iteration 1801 / 4900) loss: 1.630365\n",
      "(Iteration 1901 / 4900) loss: 1.565908\n",
      "(Epoch 4 / 10) train acc: 0.403000; val_acc: 0.412000\n",
      "(Iteration 2001 / 4900) loss: 1.541902\n",
      "(Iteration 2101 / 4900) loss: 1.605135\n",
      "(Iteration 2201 / 4900) loss: 1.604285\n",
      "(Iteration 2301 / 4900) loss: 1.664992\n",
      "(Iteration 2401 / 4900) loss: 1.739713\n",
      "(Epoch 5 / 10) train acc: 0.431000; val_acc: 0.436000\n",
      "(Iteration 2501 / 4900) loss: 1.577392\n",
      "(Iteration 2601 / 4900) loss: 1.650372\n",
      "(Iteration 2701 / 4900) loss: 1.688525\n",
      "(Iteration 2801 / 4900) loss: 1.783931\n",
      "(Iteration 2901 / 4900) loss: 1.656413\n",
      "(Epoch 6 / 10) train acc: 0.447000; val_acc: 0.453000\n",
      "(Iteration 3001 / 4900) loss: 1.614972\n",
      "(Iteration 3101 / 4900) loss: 1.488362\n",
      "(Iteration 3201 / 4900) loss: 1.593699\n",
      "(Iteration 3301 / 4900) loss: 1.564431\n",
      "(Iteration 3401 / 4900) loss: 1.342309\n",
      "(Epoch 7 / 10) train acc: 0.464000; val_acc: 0.456000\n",
      "(Iteration 3501 / 4900) loss: 1.820671\n",
      "(Iteration 3601 / 4900) loss: 1.742206\n",
      "(Iteration 3701 / 4900) loss: 1.627583\n",
      "(Iteration 3801 / 4900) loss: 1.545775\n",
      "(Iteration 3901 / 4900) loss: 1.645760\n",
      "(Epoch 8 / 10) train acc: 0.479000; val_acc: 0.474000\n",
      "(Iteration 4001 / 4900) loss: 1.558877\n",
      "(Iteration 4101 / 4900) loss: 1.611758\n",
      "(Iteration 4201 / 4900) loss: 1.576391\n",
      "(Iteration 4301 / 4900) loss: 1.540941\n",
      "(Iteration 4401 / 4900) loss: 1.562834\n",
      "(Epoch 9 / 10) train acc: 0.479000; val_acc: 0.475000\n",
      "(Iteration 4501 / 4900) loss: 1.435016\n",
      "(Iteration 4601 / 4900) loss: 1.445871\n",
      "(Iteration 4701 / 4900) loss: 1.402820\n",
      "(Iteration 4801 / 4900) loss: 1.593682\n",
      "(Epoch 10 / 10) train acc: 0.474000; val_acc: 0.472000\n",
      "80 0.0001 10 0.2\n",
      "Validation accuracy:  0.475\n",
      "(Iteration 1 / 4900) loss: 2.309445\n",
      "(Epoch 0 / 10) train acc: 0.105000; val_acc: 0.111000\n",
      "(Iteration 101 / 4900) loss: 2.226785\n",
      "(Iteration 201 / 4900) loss: 2.130805\n",
      "(Iteration 301 / 4900) loss: 2.054731\n",
      "(Iteration 401 / 4900) loss: 1.985569\n",
      "(Epoch 1 / 10) train acc: 0.335000; val_acc: 0.319000\n",
      "(Iteration 501 / 4900) loss: 1.991665\n",
      "(Iteration 601 / 4900) loss: 1.948559\n",
      "(Iteration 701 / 4900) loss: 1.745837\n",
      "(Iteration 801 / 4900) loss: 1.877426\n",
      "(Iteration 901 / 4900) loss: 1.805467\n",
      "(Epoch 2 / 10) train acc: 0.335000; val_acc: 0.370000\n",
      "(Iteration 1001 / 4900) loss: 1.689811\n",
      "(Iteration 1101 / 4900) loss: 1.735454\n",
      "(Iteration 1201 / 4900) loss: 1.613613\n",
      "(Iteration 1301 / 4900) loss: 1.712801\n",
      "(Iteration 1401 / 4900) loss: 1.863402\n",
      "(Epoch 3 / 10) train acc: 0.381000; val_acc: 0.417000\n",
      "(Iteration 1501 / 4900) loss: 1.649954\n",
      "(Iteration 1601 / 4900) loss: 1.682150\n",
      "(Iteration 1701 / 4900) loss: 1.657717\n",
      "(Iteration 1801 / 4900) loss: 1.744148\n",
      "(Iteration 1901 / 4900) loss: 1.617671\n",
      "(Epoch 4 / 10) train acc: 0.409000; val_acc: 0.427000\n",
      "(Iteration 2001 / 4900) loss: 1.669759\n",
      "(Iteration 2101 / 4900) loss: 1.739408\n",
      "(Iteration 2201 / 4900) loss: 1.694659\n",
      "(Iteration 2301 / 4900) loss: 1.585807\n",
      "(Iteration 2401 / 4900) loss: 1.654381\n",
      "(Epoch 5 / 10) train acc: 0.435000; val_acc: 0.432000\n",
      "(Iteration 2501 / 4900) loss: 1.494633\n",
      "(Iteration 2601 / 4900) loss: 1.731310\n",
      "(Iteration 2701 / 4900) loss: 1.574853\n",
      "(Iteration 2801 / 4900) loss: 1.744270\n",
      "(Iteration 2901 / 4900) loss: 1.697368\n",
      "(Epoch 6 / 10) train acc: 0.448000; val_acc: 0.441000\n",
      "(Iteration 3001 / 4900) loss: 1.670793\n",
      "(Iteration 3101 / 4900) loss: 1.613416\n",
      "(Iteration 3201 / 4900) loss: 1.352414\n",
      "(Iteration 3301 / 4900) loss: 1.483575\n",
      "(Iteration 3401 / 4900) loss: 1.705785\n",
      "(Epoch 7 / 10) train acc: 0.442000; val_acc: 0.456000\n",
      "(Iteration 3501 / 4900) loss: 1.574874\n",
      "(Iteration 3601 / 4900) loss: 1.652148\n",
      "(Iteration 3701 / 4900) loss: 1.607997\n",
      "(Iteration 3801 / 4900) loss: 1.398778\n",
      "(Iteration 3901 / 4900) loss: 1.385799\n",
      "(Epoch 8 / 10) train acc: 0.468000; val_acc: 0.457000\n",
      "(Iteration 4001 / 4900) loss: 1.613039\n",
      "(Iteration 4101 / 4900) loss: 1.436752\n",
      "(Iteration 4201 / 4900) loss: 1.441808\n",
      "(Iteration 4301 / 4900) loss: 1.638770\n",
      "(Iteration 4401 / 4900) loss: 1.393390\n",
      "(Epoch 9 / 10) train acc: 0.480000; val_acc: 0.464000\n",
      "(Iteration 4501 / 4900) loss: 1.536587\n",
      "(Iteration 4601 / 4900) loss: 1.335281\n",
      "(Iteration 4701 / 4900) loss: 1.578613\n",
      "(Iteration 4801 / 4900) loss: 1.541843\n",
      "(Epoch 10 / 10) train acc: 0.462000; val_acc: 0.459000\n",
      "100 0.0001 10 0.05\n",
      "Validation accuracy:  0.464\n",
      "(Iteration 1 / 4900) loss: 2.315170\n",
      "(Epoch 0 / 10) train acc: 0.128000; val_acc: 0.129000\n",
      "(Iteration 101 / 4900) loss: 2.228880\n",
      "(Iteration 201 / 4900) loss: 2.110153\n",
      "(Iteration 301 / 4900) loss: 2.019663\n",
      "(Iteration 401 / 4900) loss: 2.084529\n",
      "(Epoch 1 / 10) train acc: 0.283000; val_acc: 0.316000\n",
      "(Iteration 501 / 4900) loss: 2.003940\n",
      "(Iteration 601 / 4900) loss: 1.922981\n",
      "(Iteration 701 / 4900) loss: 1.993561\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 801 / 4900) loss: 1.792454\n",
      "(Iteration 901 / 4900) loss: 1.953958\n",
      "(Epoch 2 / 10) train acc: 0.384000; val_acc: 0.382000\n",
      "(Iteration 1001 / 4900) loss: 1.658486\n",
      "(Iteration 1101 / 4900) loss: 1.629114\n",
      "(Iteration 1201 / 4900) loss: 1.672306\n",
      "(Iteration 1301 / 4900) loss: 1.643215\n",
      "(Iteration 1401 / 4900) loss: 1.667090\n",
      "(Epoch 3 / 10) train acc: 0.429000; val_acc: 0.408000\n",
      "(Iteration 1501 / 4900) loss: 1.687358\n",
      "(Iteration 1601 / 4900) loss: 1.758769\n",
      "(Iteration 1701 / 4900) loss: 1.669177\n",
      "(Iteration 1801 / 4900) loss: 1.851631\n",
      "(Iteration 1901 / 4900) loss: 1.715649\n",
      "(Epoch 4 / 10) train acc: 0.410000; val_acc: 0.432000\n",
      "(Iteration 2001 / 4900) loss: 1.613520\n",
      "(Iteration 2101 / 4900) loss: 1.632804\n",
      "(Iteration 2201 / 4900) loss: 1.589177\n",
      "(Iteration 2301 / 4900) loss: 1.710290\n",
      "(Iteration 2401 / 4900) loss: 1.641501\n",
      "(Epoch 5 / 10) train acc: 0.443000; val_acc: 0.446000\n",
      "(Iteration 2501 / 4900) loss: 1.692765\n",
      "(Iteration 2601 / 4900) loss: 1.643771\n",
      "(Iteration 2701 / 4900) loss: 1.582691\n",
      "(Iteration 2801 / 4900) loss: 1.548778\n",
      "(Iteration 2901 / 4900) loss: 1.497489\n",
      "(Epoch 6 / 10) train acc: 0.474000; val_acc: 0.464000\n",
      "(Iteration 3001 / 4900) loss: 1.678612\n",
      "(Iteration 3101 / 4900) loss: 1.560914\n",
      "(Iteration 3201 / 4900) loss: 1.653879\n",
      "(Iteration 3301 / 4900) loss: 1.360914\n",
      "(Iteration 3401 / 4900) loss: 1.494879\n",
      "(Epoch 7 / 10) train acc: 0.448000; val_acc: 0.460000\n",
      "(Iteration 3501 / 4900) loss: 1.711641\n",
      "(Iteration 3601 / 4900) loss: 1.681005\n",
      "(Iteration 3701 / 4900) loss: 1.688458\n",
      "(Iteration 3801 / 4900) loss: 1.577263\n",
      "(Iteration 3901 / 4900) loss: 1.596318\n",
      "(Epoch 8 / 10) train acc: 0.488000; val_acc: 0.477000\n",
      "(Iteration 4001 / 4900) loss: 1.513730\n",
      "(Iteration 4101 / 4900) loss: 1.413104\n",
      "(Iteration 4201 / 4900) loss: 1.603515\n",
      "(Iteration 4301 / 4900) loss: 1.528594\n",
      "(Iteration 4401 / 4900) loss: 1.433402\n",
      "(Epoch 9 / 10) train acc: 0.485000; val_acc: 0.483000\n",
      "(Iteration 4501 / 4900) loss: 1.528114\n",
      "(Iteration 4601 / 4900) loss: 1.435809\n",
      "(Iteration 4701 / 4900) loss: 1.464174\n",
      "(Iteration 4801 / 4900) loss: 1.488757\n",
      "(Epoch 10 / 10) train acc: 0.451000; val_acc: 0.481000\n",
      "100 0.0001 10 0.1\n",
      "Validation accuracy:  0.483\n",
      "(Iteration 1 / 4900) loss: 2.339769\n",
      "(Epoch 0 / 10) train acc: 0.087000; val_acc: 0.082000\n",
      "(Iteration 101 / 4900) loss: 2.280673\n",
      "(Iteration 201 / 4900) loss: 2.165219\n",
      "(Iteration 301 / 4900) loss: 2.085512\n",
      "(Iteration 401 / 4900) loss: 2.066353\n",
      "(Epoch 1 / 10) train acc: 0.328000; val_acc: 0.311000\n",
      "(Iteration 501 / 4900) loss: 1.956058\n",
      "(Iteration 601 / 4900) loss: 2.050022\n",
      "(Iteration 701 / 4900) loss: 1.948100\n",
      "(Iteration 801 / 4900) loss: 1.858971\n",
      "(Iteration 901 / 4900) loss: 1.909752\n",
      "(Epoch 2 / 10) train acc: 0.373000; val_acc: 0.377000\n",
      "(Iteration 1001 / 4900) loss: 1.832288\n",
      "(Iteration 1101 / 4900) loss: 1.798206\n",
      "(Iteration 1201 / 4900) loss: 1.731341\n",
      "(Iteration 1301 / 4900) loss: 1.950663\n",
      "(Iteration 1401 / 4900) loss: 1.752304\n",
      "(Epoch 3 / 10) train acc: 0.393000; val_acc: 0.396000\n",
      "(Iteration 1501 / 4900) loss: 1.751816\n",
      "(Iteration 1601 / 4900) loss: 1.756963\n",
      "(Iteration 1701 / 4900) loss: 1.757254\n",
      "(Iteration 1801 / 4900) loss: 1.722578\n",
      "(Iteration 1901 / 4900) loss: 1.741192\n",
      "(Epoch 4 / 10) train acc: 0.423000; val_acc: 0.430000\n",
      "(Iteration 2001 / 4900) loss: 1.657401\n",
      "(Iteration 2101 / 4900) loss: 1.579616\n",
      "(Iteration 2201 / 4900) loss: 1.638794\n",
      "(Iteration 2301 / 4900) loss: 1.649913\n",
      "(Iteration 2401 / 4900) loss: 1.510425\n",
      "(Epoch 5 / 10) train acc: 0.410000; val_acc: 0.450000\n",
      "(Iteration 2501 / 4900) loss: 1.797852\n",
      "(Iteration 2601 / 4900) loss: 1.702411\n",
      "(Iteration 2701 / 4900) loss: 1.621418\n",
      "(Iteration 2801 / 4900) loss: 1.745377\n",
      "(Iteration 2901 / 4900) loss: 1.570473\n",
      "(Epoch 6 / 10) train acc: 0.433000; val_acc: 0.450000\n",
      "(Iteration 3001 / 4900) loss: 1.942352\n",
      "(Iteration 3101 / 4900) loss: 1.614163\n",
      "(Iteration 3201 / 4900) loss: 1.637959\n",
      "(Iteration 3301 / 4900) loss: 1.596756\n",
      "(Iteration 3401 / 4900) loss: 1.578203\n",
      "(Epoch 7 / 10) train acc: 0.454000; val_acc: 0.454000\n",
      "(Iteration 3501 / 4900) loss: 1.677968\n",
      "(Iteration 3601 / 4900) loss: 1.802702\n",
      "(Iteration 3701 / 4900) loss: 1.631905\n",
      "(Iteration 3801 / 4900) loss: 1.739261\n",
      "(Iteration 3901 / 4900) loss: 1.427550\n",
      "(Epoch 8 / 10) train acc: 0.464000; val_acc: 0.467000\n",
      "(Iteration 4001 / 4900) loss: 1.623745\n",
      "(Iteration 4101 / 4900) loss: 1.464755\n",
      "(Iteration 4201 / 4900) loss: 1.685735\n",
      "(Iteration 4301 / 4900) loss: 1.465426\n",
      "(Iteration 4401 / 4900) loss: 1.435505\n",
      "(Epoch 9 / 10) train acc: 0.482000; val_acc: 0.460000\n",
      "(Iteration 4501 / 4900) loss: 1.580471\n",
      "(Iteration 4601 / 4900) loss: 1.534486\n",
      "(Iteration 4701 / 4900) loss: 1.603726\n",
      "(Iteration 4801 / 4900) loss: 1.612268\n",
      "(Epoch 10 / 10) train acc: 0.493000; val_acc: 0.474000\n",
      "100 0.0001 10 0.2\n",
      "Validation accuracy:  0.474\n",
      "(Iteration 1 / 4900) loss: 2.307891\n",
      "(Epoch 0 / 10) train acc: 0.144000; val_acc: 0.147000\n",
      "(Iteration 101 / 4900) loss: 2.073263\n",
      "(Iteration 201 / 4900) loss: 1.720523\n",
      "(Iteration 301 / 4900) loss: 1.648952\n",
      "(Iteration 401 / 4900) loss: 1.690103\n",
      "(Epoch 1 / 10) train acc: 0.421000; val_acc: 0.415000\n",
      "(Iteration 501 / 4900) loss: 1.777373\n",
      "(Iteration 601 / 4900) loss: 1.600810\n",
      "(Iteration 701 / 4900) loss: 1.557225\n",
      "(Iteration 801 / 4900) loss: 1.619115\n",
      "(Iteration 901 / 4900) loss: 1.599590\n",
      "(Epoch 2 / 10) train acc: 0.444000; val_acc: 0.437000\n",
      "(Iteration 1001 / 4900) loss: 1.520648\n",
      "(Iteration 1101 / 4900) loss: 1.478898\n",
      "(Iteration 1201 / 4900) loss: 1.379314\n",
      "(Iteration 1301 / 4900) loss: 1.776117\n",
      "(Iteration 1401 / 4900) loss: 1.583708\n",
      "(Epoch 3 / 10) train acc: 0.478000; val_acc: 0.461000\n",
      "(Iteration 1501 / 4900) loss: 1.704375\n",
      "(Iteration 1601 / 4900) loss: 1.479663\n",
      "(Iteration 1701 / 4900) loss: 1.565919\n",
      "(Iteration 1801 / 4900) loss: 1.512982\n",
      "(Iteration 1901 / 4900) loss: 1.306417\n",
      "(Epoch 4 / 10) train acc: 0.504000; val_acc: 0.461000\n",
      "(Iteration 2001 / 4900) loss: 1.352387\n",
      "(Iteration 2101 / 4900) loss: 1.454852\n",
      "(Iteration 2201 / 4900) loss: 1.474433\n",
      "(Iteration 2301 / 4900) loss: 1.359501\n",
      "(Iteration 2401 / 4900) loss: 1.452444\n",
      "(Epoch 5 / 10) train acc: 0.526000; val_acc: 0.480000\n",
      "(Iteration 2501 / 4900) loss: 1.557811\n",
      "(Iteration 2601 / 4900) loss: 1.389363\n",
      "(Iteration 2701 / 4900) loss: 1.534676\n",
      "(Iteration 2801 / 4900) loss: 1.468745\n",
      "(Iteration 2901 / 4900) loss: 1.527772\n",
      "(Epoch 6 / 10) train acc: 0.513000; val_acc: 0.495000\n",
      "(Iteration 3001 / 4900) loss: 1.434803\n",
      "(Iteration 3101 / 4900) loss: 1.247507\n",
      "(Iteration 3201 / 4900) loss: 1.413822\n",
      "(Iteration 3301 / 4900) loss: 1.341625\n",
      "(Iteration 3401 / 4900) loss: 1.380373\n",
      "(Epoch 7 / 10) train acc: 0.505000; val_acc: 0.495000\n",
      "(Iteration 3501 / 4900) loss: 1.261720\n",
      "(Iteration 3601 / 4900) loss: 1.328659\n",
      "(Iteration 3701 / 4900) loss: 1.115151\n",
      "(Iteration 3801 / 4900) loss: 1.460380\n",
      "(Iteration 3901 / 4900) loss: 1.542151\n",
      "(Epoch 8 / 10) train acc: 0.531000; val_acc: 0.506000\n",
      "(Iteration 4001 / 4900) loss: 1.381525\n",
      "(Iteration 4101 / 4900) loss: 1.306242\n",
      "(Iteration 4201 / 4900) loss: 1.258648\n",
      "(Iteration 4301 / 4900) loss: 1.166658\n",
      "(Iteration 4401 / 4900) loss: 1.335756\n",
      "(Epoch 9 / 10) train acc: 0.553000; val_acc: 0.490000\n",
      "(Iteration 4501 / 4900) loss: 1.244410\n",
      "(Iteration 4601 / 4900) loss: 1.321836\n",
      "(Iteration 4701 / 4900) loss: 1.377548\n",
      "(Iteration 4801 / 4900) loss: 1.198807\n",
      "(Epoch 10 / 10) train acc: 0.570000; val_acc: 0.486000\n",
      "50 0.0005 10 0.05\n",
      "Validation accuracy:  0.506\n",
      "(Iteration 1 / 4900) loss: 2.312686\n",
      "(Epoch 0 / 10) train acc: 0.107000; val_acc: 0.119000\n",
      "(Iteration 101 / 4900) loss: 2.058717\n",
      "(Iteration 201 / 4900) loss: 1.669977\n",
      "(Iteration 301 / 4900) loss: 1.831421\n",
      "(Iteration 401 / 4900) loss: 1.761113\n",
      "(Epoch 1 / 10) train acc: 0.443000; val_acc: 0.429000\n",
      "(Iteration 501 / 4900) loss: 1.616587\n",
      "(Iteration 601 / 4900) loss: 1.572358\n",
      "(Iteration 701 / 4900) loss: 1.420461\n",
      "(Iteration 801 / 4900) loss: 1.538633\n",
      "(Iteration 901 / 4900) loss: 1.705772\n",
      "(Epoch 2 / 10) train acc: 0.450000; val_acc: 0.451000\n",
      "(Iteration 1001 / 4900) loss: 1.508990\n",
      "(Iteration 1101 / 4900) loss: 1.473862\n",
      "(Iteration 1201 / 4900) loss: 1.576708\n",
      "(Iteration 1301 / 4900) loss: 1.549185\n",
      "(Iteration 1401 / 4900) loss: 1.538679\n",
      "(Epoch 3 / 10) train acc: 0.469000; val_acc: 0.452000\n",
      "(Iteration 1501 / 4900) loss: 1.460463\n",
      "(Iteration 1601 / 4900) loss: 1.490607\n",
      "(Iteration 1701 / 4900) loss: 1.498834\n",
      "(Iteration 1801 / 4900) loss: 1.481752\n",
      "(Iteration 1901 / 4900) loss: 1.477536\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Epoch 4 / 10) train acc: 0.481000; val_acc: 0.475000\n",
      "(Iteration 2001 / 4900) loss: 1.511383\n",
      "(Iteration 2101 / 4900) loss: 1.406420\n",
      "(Iteration 2201 / 4900) loss: 1.301996\n",
      "(Iteration 2301 / 4900) loss: 1.586283\n",
      "(Iteration 2401 / 4900) loss: 1.469884\n",
      "(Epoch 5 / 10) train acc: 0.497000; val_acc: 0.489000\n",
      "(Iteration 2501 / 4900) loss: 1.509734\n",
      "(Iteration 2601 / 4900) loss: 1.377873\n",
      "(Iteration 2701 / 4900) loss: 1.260473\n",
      "(Iteration 2801 / 4900) loss: 1.479312\n",
      "(Iteration 2901 / 4900) loss: 1.265382\n",
      "(Epoch 6 / 10) train acc: 0.526000; val_acc: 0.489000\n",
      "(Iteration 3001 / 4900) loss: 1.519671\n",
      "(Iteration 3101 / 4900) loss: 1.347162\n",
      "(Iteration 3201 / 4900) loss: 1.153120\n",
      "(Iteration 3301 / 4900) loss: 1.292477\n",
      "(Iteration 3401 / 4900) loss: 1.217664\n",
      "(Epoch 7 / 10) train acc: 0.536000; val_acc: 0.498000\n",
      "(Iteration 3501 / 4900) loss: 1.377359\n",
      "(Iteration 3601 / 4900) loss: 1.350897\n",
      "(Iteration 3701 / 4900) loss: 1.538563\n",
      "(Iteration 3801 / 4900) loss: 1.677594\n",
      "(Iteration 3901 / 4900) loss: 1.362590\n",
      "(Epoch 8 / 10) train acc: 0.521000; val_acc: 0.496000\n",
      "(Iteration 4001 / 4900) loss: 1.465191\n",
      "(Iteration 4101 / 4900) loss: 1.262676\n",
      "(Iteration 4201 / 4900) loss: 1.150067\n",
      "(Iteration 4301 / 4900) loss: 1.067451\n",
      "(Iteration 4401 / 4900) loss: 1.300367\n",
      "(Epoch 9 / 10) train acc: 0.532000; val_acc: 0.489000\n",
      "(Iteration 4501 / 4900) loss: 1.166672\n",
      "(Iteration 4601 / 4900) loss: 1.252850\n",
      "(Iteration 4701 / 4900) loss: 1.565724\n",
      "(Iteration 4801 / 4900) loss: 1.326913\n",
      "(Epoch 10 / 10) train acc: 0.559000; val_acc: 0.490000\n",
      "50 0.0005 10 0.1\n",
      "Validation accuracy:  0.498\n",
      "(Iteration 1 / 4900) loss: 2.319012\n",
      "(Epoch 0 / 10) train acc: 0.105000; val_acc: 0.097000\n",
      "(Iteration 101 / 4900) loss: 1.944016\n",
      "(Iteration 201 / 4900) loss: 1.910639\n",
      "(Iteration 301 / 4900) loss: 1.731081\n",
      "(Iteration 401 / 4900) loss: 1.823205\n",
      "(Epoch 1 / 10) train acc: 0.422000; val_acc: 0.435000\n",
      "(Iteration 501 / 4900) loss: 1.680309\n",
      "(Iteration 601 / 4900) loss: 1.719317\n",
      "(Iteration 701 / 4900) loss: 1.602286\n",
      "(Iteration 801 / 4900) loss: 1.531042\n",
      "(Iteration 901 / 4900) loss: 1.457091\n",
      "(Epoch 2 / 10) train acc: 0.466000; val_acc: 0.443000\n",
      "(Iteration 1001 / 4900) loss: 1.581603\n",
      "(Iteration 1101 / 4900) loss: 1.678794\n",
      "(Iteration 1201 / 4900) loss: 1.516973\n",
      "(Iteration 1301 / 4900) loss: 1.451435\n",
      "(Iteration 1401 / 4900) loss: 1.627169\n",
      "(Epoch 3 / 10) train acc: 0.484000; val_acc: 0.471000\n",
      "(Iteration 1501 / 4900) loss: 1.439595\n",
      "(Iteration 1601 / 4900) loss: 1.408075\n",
      "(Iteration 1701 / 4900) loss: 1.505033\n",
      "(Iteration 1801 / 4900) loss: 1.368582\n",
      "(Iteration 1901 / 4900) loss: 1.430040\n",
      "(Epoch 4 / 10) train acc: 0.511000; val_acc: 0.457000\n",
      "(Iteration 2001 / 4900) loss: 1.413093\n",
      "(Iteration 2101 / 4900) loss: 1.619307\n",
      "(Iteration 2201 / 4900) loss: 1.318978\n",
      "(Iteration 2301 / 4900) loss: 1.660454\n",
      "(Iteration 2401 / 4900) loss: 1.589588\n",
      "(Epoch 5 / 10) train acc: 0.506000; val_acc: 0.474000\n",
      "(Iteration 2501 / 4900) loss: 1.501910\n",
      "(Iteration 2601 / 4900) loss: 1.572275\n",
      "(Iteration 2701 / 4900) loss: 1.504970\n",
      "(Iteration 2801 / 4900) loss: 1.407209\n",
      "(Iteration 2901 / 4900) loss: 1.414186\n",
      "(Epoch 6 / 10) train acc: 0.543000; val_acc: 0.496000\n",
      "(Iteration 3001 / 4900) loss: 1.320084\n",
      "(Iteration 3101 / 4900) loss: 1.305874\n",
      "(Iteration 3201 / 4900) loss: 1.264940\n",
      "(Iteration 3301 / 4900) loss: 1.565367\n",
      "(Iteration 3401 / 4900) loss: 1.576945\n",
      "(Epoch 7 / 10) train acc: 0.530000; val_acc: 0.487000\n",
      "(Iteration 3501 / 4900) loss: 1.544329\n",
      "(Iteration 3601 / 4900) loss: 1.444702\n",
      "(Iteration 3701 / 4900) loss: 1.543516\n",
      "(Iteration 3801 / 4900) loss: 1.216307\n",
      "(Iteration 3901 / 4900) loss: 1.380864\n",
      "(Epoch 8 / 10) train acc: 0.553000; val_acc: 0.497000\n",
      "(Iteration 4001 / 4900) loss: 1.315406\n",
      "(Iteration 4101 / 4900) loss: 1.343504\n",
      "(Iteration 4201 / 4900) loss: 1.385101\n",
      "(Iteration 4301 / 4900) loss: 1.449981\n",
      "(Iteration 4401 / 4900) loss: 1.319958\n",
      "(Epoch 9 / 10) train acc: 0.532000; val_acc: 0.497000\n",
      "(Iteration 4501 / 4900) loss: 1.502637\n",
      "(Iteration 4601 / 4900) loss: 1.337086\n",
      "(Iteration 4701 / 4900) loss: 1.290692\n",
      "(Iteration 4801 / 4900) loss: 1.421132\n",
      "(Epoch 10 / 10) train acc: 0.508000; val_acc: 0.513000\n",
      "50 0.0005 10 0.2\n",
      "Validation accuracy:  0.513\n",
      "(Iteration 1 / 4900) loss: 2.307205\n",
      "(Epoch 0 / 10) train acc: 0.089000; val_acc: 0.111000\n",
      "(Iteration 101 / 4900) loss: 1.938851\n",
      "(Iteration 201 / 4900) loss: 1.762274\n",
      "(Iteration 301 / 4900) loss: 1.625372\n",
      "(Iteration 401 / 4900) loss: 1.816109\n",
      "(Epoch 1 / 10) train acc: 0.410000; val_acc: 0.424000\n",
      "(Iteration 501 / 4900) loss: 1.592039\n",
      "(Iteration 601 / 4900) loss: 1.550764\n",
      "(Iteration 701 / 4900) loss: 1.570297\n",
      "(Iteration 801 / 4900) loss: 1.491268\n",
      "(Iteration 901 / 4900) loss: 1.510803\n",
      "(Epoch 2 / 10) train acc: 0.463000; val_acc: 0.478000\n",
      "(Iteration 1001 / 4900) loss: 1.493304\n",
      "(Iteration 1101 / 4900) loss: 1.353238\n",
      "(Iteration 1201 / 4900) loss: 1.292564\n",
      "(Iteration 1301 / 4900) loss: 1.563410\n",
      "(Iteration 1401 / 4900) loss: 1.525119\n",
      "(Epoch 3 / 10) train acc: 0.498000; val_acc: 0.481000\n",
      "(Iteration 1501 / 4900) loss: 1.531052\n",
      "(Iteration 1601 / 4900) loss: 1.598403\n",
      "(Iteration 1701 / 4900) loss: 1.502711\n",
      "(Iteration 1801 / 4900) loss: 1.469487\n",
      "(Iteration 1901 / 4900) loss: 1.371842\n",
      "(Epoch 4 / 10) train acc: 0.512000; val_acc: 0.496000\n",
      "(Iteration 2001 / 4900) loss: 1.228126\n",
      "(Iteration 2101 / 4900) loss: 1.518300\n",
      "(Iteration 2201 / 4900) loss: 1.426917\n",
      "(Iteration 2301 / 4900) loss: 1.352560\n",
      "(Iteration 2401 / 4900) loss: 1.413260\n",
      "(Epoch 5 / 10) train acc: 0.533000; val_acc: 0.483000\n",
      "(Iteration 2501 / 4900) loss: 1.511522\n",
      "(Iteration 2601 / 4900) loss: 1.515986\n",
      "(Iteration 2701 / 4900) loss: 1.288134\n",
      "(Iteration 2801 / 4900) loss: 1.322968\n",
      "(Iteration 2901 / 4900) loss: 1.257334\n",
      "(Epoch 6 / 10) train acc: 0.529000; val_acc: 0.497000\n",
      "(Iteration 3001 / 4900) loss: 1.277202\n",
      "(Iteration 3101 / 4900) loss: 1.274389\n",
      "(Iteration 3201 / 4900) loss: 1.459042\n",
      "(Iteration 3301 / 4900) loss: 1.197729\n",
      "(Iteration 3401 / 4900) loss: 1.343551\n",
      "(Epoch 7 / 10) train acc: 0.611000; val_acc: 0.518000\n",
      "(Iteration 3501 / 4900) loss: 1.196157\n",
      "(Iteration 3601 / 4900) loss: 1.115596\n",
      "(Iteration 3701 / 4900) loss: 1.398484\n",
      "(Iteration 3801 / 4900) loss: 1.303260\n",
      "(Iteration 3901 / 4900) loss: 1.329931\n",
      "(Epoch 8 / 10) train acc: 0.530000; val_acc: 0.494000\n",
      "(Iteration 4001 / 4900) loss: 1.268153\n",
      "(Iteration 4101 / 4900) loss: 1.121154\n",
      "(Iteration 4201 / 4900) loss: 1.316956\n",
      "(Iteration 4301 / 4900) loss: 1.166494\n",
      "(Iteration 4401 / 4900) loss: 1.400493\n",
      "(Epoch 9 / 10) train acc: 0.568000; val_acc: 0.500000\n",
      "(Iteration 4501 / 4900) loss: 1.344218\n",
      "(Iteration 4601 / 4900) loss: 1.181808\n",
      "(Iteration 4701 / 4900) loss: 1.326092\n",
      "(Iteration 4801 / 4900) loss: 1.309463\n",
      "(Epoch 10 / 10) train acc: 0.613000; val_acc: 0.500000\n",
      "80 0.0005 10 0.05\n",
      "Validation accuracy:  0.518\n",
      "(Iteration 1 / 4900) loss: 2.309354\n",
      "(Epoch 0 / 10) train acc: 0.150000; val_acc: 0.135000\n",
      "(Iteration 101 / 4900) loss: 1.964904\n",
      "(Iteration 201 / 4900) loss: 1.720260\n",
      "(Iteration 301 / 4900) loss: 1.627046\n",
      "(Iteration 401 / 4900) loss: 1.688669\n",
      "(Epoch 1 / 10) train acc: 0.398000; val_acc: 0.445000\n",
      "(Iteration 501 / 4900) loss: 1.460962\n",
      "(Iteration 601 / 4900) loss: 1.715749\n",
      "(Iteration 701 / 4900) loss: 1.584440\n",
      "(Iteration 801 / 4900) loss: 1.559688\n",
      "(Iteration 901 / 4900) loss: 1.698036\n",
      "(Epoch 2 / 10) train acc: 0.459000; val_acc: 0.449000\n",
      "(Iteration 1001 / 4900) loss: 1.611656\n",
      "(Iteration 1101 / 4900) loss: 1.496941\n",
      "(Iteration 1201 / 4900) loss: 1.796608\n",
      "(Iteration 1301 / 4900) loss: 1.369408\n",
      "(Iteration 1401 / 4900) loss: 1.405387\n",
      "(Epoch 3 / 10) train acc: 0.496000; val_acc: 0.473000\n",
      "(Iteration 1501 / 4900) loss: 1.353289\n",
      "(Iteration 1601 / 4900) loss: 1.394640\n",
      "(Iteration 1701 / 4900) loss: 1.489681\n",
      "(Iteration 1801 / 4900) loss: 1.470507\n",
      "(Iteration 1901 / 4900) loss: 1.165004\n",
      "(Epoch 4 / 10) train acc: 0.540000; val_acc: 0.487000\n",
      "(Iteration 2001 / 4900) loss: 1.387007\n",
      "(Iteration 2101 / 4900) loss: 1.330656\n",
      "(Iteration 2201 / 4900) loss: 1.512718\n",
      "(Iteration 2301 / 4900) loss: 1.308913\n",
      "(Iteration 2401 / 4900) loss: 1.256184\n",
      "(Epoch 5 / 10) train acc: 0.540000; val_acc: 0.478000\n",
      "(Iteration 2501 / 4900) loss: 1.270454\n",
      "(Iteration 2601 / 4900) loss: 1.347180\n",
      "(Iteration 2701 / 4900) loss: 1.411248\n",
      "(Iteration 2801 / 4900) loss: 1.447742\n",
      "(Iteration 2901 / 4900) loss: 1.372227\n",
      "(Epoch 6 / 10) train acc: 0.566000; val_acc: 0.498000\n",
      "(Iteration 3001 / 4900) loss: 1.504245\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 3101 / 4900) loss: 1.372644\n",
      "(Iteration 3201 / 4900) loss: 1.363809\n",
      "(Iteration 3301 / 4900) loss: 1.264223\n",
      "(Iteration 3401 / 4900) loss: 1.379176\n",
      "(Epoch 7 / 10) train acc: 0.548000; val_acc: 0.509000\n",
      "(Iteration 3501 / 4900) loss: 1.355683\n",
      "(Iteration 3601 / 4900) loss: 1.314576\n",
      "(Iteration 3701 / 4900) loss: 1.409052\n",
      "(Iteration 3801 / 4900) loss: 1.137824\n",
      "(Iteration 3901 / 4900) loss: 1.371698\n",
      "(Epoch 8 / 10) train acc: 0.546000; val_acc: 0.506000\n",
      "(Iteration 4001 / 4900) loss: 1.267667\n",
      "(Iteration 4101 / 4900) loss: 1.150014\n",
      "(Iteration 4201 / 4900) loss: 1.436479\n",
      "(Iteration 4301 / 4900) loss: 1.490315\n",
      "(Iteration 4401 / 4900) loss: 1.478317\n",
      "(Epoch 9 / 10) train acc: 0.611000; val_acc: 0.505000\n",
      "(Iteration 4501 / 4900) loss: 1.305591\n",
      "(Iteration 4601 / 4900) loss: 1.218327\n",
      "(Iteration 4701 / 4900) loss: 1.322931\n",
      "(Iteration 4801 / 4900) loss: 1.388319\n",
      "(Epoch 10 / 10) train acc: 0.563000; val_acc: 0.503000\n",
      "80 0.0005 10 0.1\n",
      "Validation accuracy:  0.509\n",
      "(Iteration 1 / 4900) loss: 2.327537\n",
      "(Epoch 0 / 10) train acc: 0.137000; val_acc: 0.125000\n",
      "(Iteration 101 / 4900) loss: 1.941572\n",
      "(Iteration 201 / 4900) loss: 1.790061\n",
      "(Iteration 301 / 4900) loss: 1.703306\n",
      "(Iteration 401 / 4900) loss: 1.594561\n",
      "(Epoch 1 / 10) train acc: 0.411000; val_acc: 0.419000\n",
      "(Iteration 501 / 4900) loss: 1.745087\n",
      "(Iteration 601 / 4900) loss: 1.469194\n",
      "(Iteration 701 / 4900) loss: 1.490875\n",
      "(Iteration 801 / 4900) loss: 1.753714\n",
      "(Iteration 901 / 4900) loss: 1.494617\n",
      "(Epoch 2 / 10) train acc: 0.467000; val_acc: 0.449000\n",
      "(Iteration 1001 / 4900) loss: 1.469411\n",
      "(Iteration 1101 / 4900) loss: 1.551410\n",
      "(Iteration 1201 / 4900) loss: 1.476738\n",
      "(Iteration 1301 / 4900) loss: 1.357660\n",
      "(Iteration 1401 / 4900) loss: 1.500254\n",
      "(Epoch 3 / 10) train acc: 0.483000; val_acc: 0.479000\n",
      "(Iteration 1501 / 4900) loss: 1.622213\n",
      "(Iteration 1601 / 4900) loss: 1.296748\n",
      "(Iteration 1701 / 4900) loss: 1.433190\n",
      "(Iteration 1801 / 4900) loss: 1.382695\n",
      "(Iteration 1901 / 4900) loss: 1.610658\n",
      "(Epoch 4 / 10) train acc: 0.509000; val_acc: 0.460000\n",
      "(Iteration 2001 / 4900) loss: 1.395464\n",
      "(Iteration 2101 / 4900) loss: 1.477042\n",
      "(Iteration 2201 / 4900) loss: 1.445533\n",
      "(Iteration 2301 / 4900) loss: 1.375211\n",
      "(Iteration 2401 / 4900) loss: 1.387730\n",
      "(Epoch 5 / 10) train acc: 0.526000; val_acc: 0.495000\n",
      "(Iteration 2501 / 4900) loss: 1.361676\n",
      "(Iteration 2601 / 4900) loss: 1.294159\n",
      "(Iteration 2701 / 4900) loss: 1.263810\n",
      "(Iteration 2801 / 4900) loss: 1.398738\n",
      "(Iteration 2901 / 4900) loss: 1.436124\n",
      "(Epoch 6 / 10) train acc: 0.487000; val_acc: 0.496000\n",
      "(Iteration 3001 / 4900) loss: 1.451960\n",
      "(Iteration 3101 / 4900) loss: 1.370305\n",
      "(Iteration 3201 / 4900) loss: 1.346233\n",
      "(Iteration 3301 / 4900) loss: 1.396749\n",
      "(Iteration 3401 / 4900) loss: 1.438925\n",
      "(Epoch 7 / 10) train acc: 0.575000; val_acc: 0.496000\n",
      "(Iteration 3501 / 4900) loss: 1.178289\n",
      "(Iteration 3601 / 4900) loss: 1.289126\n",
      "(Iteration 3701 / 4900) loss: 1.313301\n",
      "(Iteration 3801 / 4900) loss: 1.301548\n",
      "(Iteration 3901 / 4900) loss: 1.225934\n",
      "(Epoch 8 / 10) train acc: 0.561000; val_acc: 0.520000\n",
      "(Iteration 4001 / 4900) loss: 1.288578\n",
      "(Iteration 4101 / 4900) loss: 1.382273\n",
      "(Iteration 4201 / 4900) loss: 1.472081\n",
      "(Iteration 4301 / 4900) loss: 1.351466\n",
      "(Iteration 4401 / 4900) loss: 1.361203\n",
      "(Epoch 9 / 10) train acc: 0.573000; val_acc: 0.517000\n",
      "(Iteration 4501 / 4900) loss: 1.377993\n",
      "(Iteration 4601 / 4900) loss: 1.267018\n",
      "(Iteration 4701 / 4900) loss: 1.393453\n",
      "(Iteration 4801 / 4900) loss: 1.170593\n",
      "(Epoch 10 / 10) train acc: 0.549000; val_acc: 0.511000\n",
      "80 0.0005 10 0.2\n",
      "Validation accuracy:  0.52\n",
      "(Iteration 1 / 4900) loss: 2.310604\n",
      "(Epoch 0 / 10) train acc: 0.108000; val_acc: 0.096000\n",
      "(Iteration 101 / 4900) loss: 1.941368\n",
      "(Iteration 201 / 4900) loss: 1.916774\n",
      "(Iteration 301 / 4900) loss: 1.788483\n",
      "(Iteration 401 / 4900) loss: 1.591180\n",
      "(Epoch 1 / 10) train acc: 0.405000; val_acc: 0.433000\n",
      "(Iteration 501 / 4900) loss: 1.759384\n",
      "(Iteration 601 / 4900) loss: 1.668082\n",
      "(Iteration 701 / 4900) loss: 1.584816\n",
      "(Iteration 801 / 4900) loss: 1.581450\n",
      "(Iteration 901 / 4900) loss: 1.563869\n",
      "(Epoch 2 / 10) train acc: 0.483000; val_acc: 0.474000\n",
      "(Iteration 1001 / 4900) loss: 1.458533\n",
      "(Iteration 1101 / 4900) loss: 1.402421\n",
      "(Iteration 1201 / 4900) loss: 1.451387\n",
      "(Iteration 1301 / 4900) loss: 1.472712\n",
      "(Iteration 1401 / 4900) loss: 1.516434\n",
      "(Epoch 3 / 10) train acc: 0.535000; val_acc: 0.489000\n",
      "(Iteration 1501 / 4900) loss: 1.492489\n",
      "(Iteration 1601 / 4900) loss: 1.538773\n",
      "(Iteration 1701 / 4900) loss: 1.445435\n",
      "(Iteration 1801 / 4900) loss: 1.598379\n",
      "(Iteration 1901 / 4900) loss: 1.571310\n",
      "(Epoch 4 / 10) train acc: 0.553000; val_acc: 0.506000\n",
      "(Iteration 2001 / 4900) loss: 1.200953\n",
      "(Iteration 2101 / 4900) loss: 1.385008\n",
      "(Iteration 2201 / 4900) loss: 1.294839\n",
      "(Iteration 2301 / 4900) loss: 1.348122\n",
      "(Iteration 2401 / 4900) loss: 1.494582\n",
      "(Epoch 5 / 10) train acc: 0.520000; val_acc: 0.501000\n",
      "(Iteration 2501 / 4900) loss: 1.245915\n",
      "(Iteration 2601 / 4900) loss: 1.316102\n",
      "(Iteration 2701 / 4900) loss: 1.379180\n",
      "(Iteration 2801 / 4900) loss: 1.210731\n",
      "(Iteration 2901 / 4900) loss: 1.208488\n",
      "(Epoch 6 / 10) train acc: 0.531000; val_acc: 0.517000\n",
      "(Iteration 3001 / 4900) loss: 1.312739\n",
      "(Iteration 3101 / 4900) loss: 1.318035\n",
      "(Iteration 3201 / 4900) loss: 1.248187\n",
      "(Iteration 3301 / 4900) loss: 1.154727\n",
      "(Iteration 3401 / 4900) loss: 1.221063\n",
      "(Epoch 7 / 10) train acc: 0.557000; val_acc: 0.515000\n",
      "(Iteration 3501 / 4900) loss: 1.149545\n",
      "(Iteration 3601 / 4900) loss: 1.158817\n",
      "(Iteration 3701 / 4900) loss: 1.352629\n",
      "(Iteration 3801 / 4900) loss: 1.289897\n",
      "(Iteration 3901 / 4900) loss: 1.383081\n",
      "(Epoch 8 / 10) train acc: 0.562000; val_acc: 0.524000\n",
      "(Iteration 4001 / 4900) loss: 1.115613\n",
      "(Iteration 4101 / 4900) loss: 1.291348\n",
      "(Iteration 4201 / 4900) loss: 1.086132\n",
      "(Iteration 4301 / 4900) loss: 0.979788\n",
      "(Iteration 4401 / 4900) loss: 1.210814\n",
      "(Epoch 9 / 10) train acc: 0.594000; val_acc: 0.516000\n",
      "(Iteration 4501 / 4900) loss: 1.264465\n",
      "(Iteration 4601 / 4900) loss: 1.194776\n",
      "(Iteration 4701 / 4900) loss: 1.296952\n",
      "(Iteration 4801 / 4900) loss: 1.115527\n",
      "(Epoch 10 / 10) train acc: 0.595000; val_acc: 0.498000\n",
      "100 0.0005 10 0.05\n",
      "Validation accuracy:  0.524\n",
      "(Iteration 1 / 4900) loss: 2.320443\n",
      "(Epoch 0 / 10) train acc: 0.111000; val_acc: 0.113000\n",
      "(Iteration 101 / 4900) loss: 2.053331\n",
      "(Iteration 201 / 4900) loss: 1.733669\n",
      "(Iteration 301 / 4900) loss: 1.549743\n",
      "(Iteration 401 / 4900) loss: 1.596613\n",
      "(Epoch 1 / 10) train acc: 0.433000; val_acc: 0.442000\n",
      "(Iteration 501 / 4900) loss: 1.624564\n",
      "(Iteration 601 / 4900) loss: 1.482910\n",
      "(Iteration 701 / 4900) loss: 1.700481\n",
      "(Iteration 801 / 4900) loss: 1.568087\n",
      "(Iteration 901 / 4900) loss: 1.565472\n",
      "(Epoch 2 / 10) train acc: 0.502000; val_acc: 0.450000\n",
      "(Iteration 1001 / 4900) loss: 1.449119\n",
      "(Iteration 1101 / 4900) loss: 1.416165\n",
      "(Iteration 1201 / 4900) loss: 1.382978\n",
      "(Iteration 1301 / 4900) loss: 1.679539\n",
      "(Iteration 1401 / 4900) loss: 1.294991\n",
      "(Epoch 3 / 10) train acc: 0.460000; val_acc: 0.472000\n",
      "(Iteration 1501 / 4900) loss: 1.231511\n",
      "(Iteration 1601 / 4900) loss: 1.261831\n",
      "(Iteration 1701 / 4900) loss: 1.399007\n",
      "(Iteration 1801 / 4900) loss: 1.347785\n",
      "(Iteration 1901 / 4900) loss: 1.610047\n",
      "(Epoch 4 / 10) train acc: 0.509000; val_acc: 0.487000\n",
      "(Iteration 2001 / 4900) loss: 1.161397\n",
      "(Iteration 2101 / 4900) loss: 1.469672\n",
      "(Iteration 2201 / 4900) loss: 1.415550\n",
      "(Iteration 2301 / 4900) loss: 1.587087\n",
      "(Iteration 2401 / 4900) loss: 1.524827\n",
      "(Epoch 5 / 10) train acc: 0.544000; val_acc: 0.501000\n",
      "(Iteration 2501 / 4900) loss: 1.493706\n",
      "(Iteration 2601 / 4900) loss: 1.321476\n",
      "(Iteration 2701 / 4900) loss: 1.443911\n",
      "(Iteration 2801 / 4900) loss: 1.254259\n",
      "(Iteration 2901 / 4900) loss: 1.281039\n",
      "(Epoch 6 / 10) train acc: 0.561000; val_acc: 0.511000\n",
      "(Iteration 3001 / 4900) loss: 1.232326\n",
      "(Iteration 3101 / 4900) loss: 1.187315\n",
      "(Iteration 3201 / 4900) loss: 1.308127\n",
      "(Iteration 3301 / 4900) loss: 1.227608\n",
      "(Iteration 3401 / 4900) loss: 1.463427\n",
      "(Epoch 7 / 10) train acc: 0.544000; val_acc: 0.508000\n",
      "(Iteration 3501 / 4900) loss: 1.277347\n",
      "(Iteration 3601 / 4900) loss: 1.356608\n",
      "(Iteration 3701 / 4900) loss: 1.522605\n",
      "(Iteration 3801 / 4900) loss: 1.368503\n",
      "(Iteration 3901 / 4900) loss: 1.124957\n",
      "(Epoch 8 / 10) train acc: 0.565000; val_acc: 0.527000\n",
      "(Iteration 4001 / 4900) loss: 1.104383\n",
      "(Iteration 4101 / 4900) loss: 1.459422\n",
      "(Iteration 4201 / 4900) loss: 1.241361\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 4301 / 4900) loss: 1.320851\n",
      "(Iteration 4401 / 4900) loss: 1.374317\n",
      "(Epoch 9 / 10) train acc: 0.559000; val_acc: 0.525000\n",
      "(Iteration 4501 / 4900) loss: 1.282295\n",
      "(Iteration 4601 / 4900) loss: 1.284054\n",
      "(Iteration 4701 / 4900) loss: 1.226826\n",
      "(Iteration 4801 / 4900) loss: 1.221030\n",
      "(Epoch 10 / 10) train acc: 0.587000; val_acc: 0.517000\n",
      "100 0.0005 10 0.1\n",
      "Validation accuracy:  0.527\n",
      "(Iteration 1 / 4900) loss: 2.335892\n",
      "(Epoch 0 / 10) train acc: 0.137000; val_acc: 0.127000\n",
      "(Iteration 101 / 4900) loss: 1.912188\n",
      "(Iteration 201 / 4900) loss: 1.862410\n",
      "(Iteration 301 / 4900) loss: 1.778691\n",
      "(Iteration 401 / 4900) loss: 1.570388\n",
      "(Epoch 1 / 10) train acc: 0.439000; val_acc: 0.427000\n",
      "(Iteration 501 / 4900) loss: 1.736065\n",
      "(Iteration 601 / 4900) loss: 1.699070\n",
      "(Iteration 701 / 4900) loss: 1.499864\n",
      "(Iteration 801 / 4900) loss: 1.706921\n",
      "(Iteration 901 / 4900) loss: 1.564257\n",
      "(Epoch 2 / 10) train acc: 0.469000; val_acc: 0.452000\n",
      "(Iteration 1001 / 4900) loss: 1.501404\n",
      "(Iteration 1101 / 4900) loss: 1.496533\n",
      "(Iteration 1201 / 4900) loss: 1.332588\n",
      "(Iteration 1301 / 4900) loss: 1.493730\n",
      "(Iteration 1401 / 4900) loss: 1.560107\n",
      "(Epoch 3 / 10) train acc: 0.502000; val_acc: 0.476000\n",
      "(Iteration 1501 / 4900) loss: 1.502107\n",
      "(Iteration 1601 / 4900) loss: 1.550668\n",
      "(Iteration 1701 / 4900) loss: 1.460260\n",
      "(Iteration 1801 / 4900) loss: 1.499511\n",
      "(Iteration 1901 / 4900) loss: 1.536589\n",
      "(Epoch 4 / 10) train acc: 0.522000; val_acc: 0.481000\n",
      "(Iteration 2001 / 4900) loss: 1.492111\n",
      "(Iteration 2101 / 4900) loss: 1.335021\n",
      "(Iteration 2201 / 4900) loss: 1.357241\n",
      "(Iteration 2301 / 4900) loss: 1.548318\n",
      "(Iteration 2401 / 4900) loss: 1.445209\n",
      "(Epoch 5 / 10) train acc: 0.547000; val_acc: 0.507000\n",
      "(Iteration 2501 / 4900) loss: 1.396443\n",
      "(Iteration 2601 / 4900) loss: 1.372466\n",
      "(Iteration 2701 / 4900) loss: 1.328325\n",
      "(Iteration 2801 / 4900) loss: 1.342246\n",
      "(Iteration 2901 / 4900) loss: 1.250290\n",
      "(Epoch 6 / 10) train acc: 0.529000; val_acc: 0.504000\n",
      "(Iteration 3001 / 4900) loss: 1.307055\n",
      "(Iteration 3101 / 4900) loss: 1.337384\n",
      "(Iteration 3201 / 4900) loss: 1.354507\n",
      "(Iteration 3301 / 4900) loss: 1.269003\n",
      "(Iteration 3401 / 4900) loss: 1.372451\n",
      "(Epoch 7 / 10) train acc: 0.576000; val_acc: 0.498000\n",
      "(Iteration 3501 / 4900) loss: 1.270686\n",
      "(Iteration 3601 / 4900) loss: 1.220702\n",
      "(Iteration 3701 / 4900) loss: 1.234889\n",
      "(Iteration 3801 / 4900) loss: 1.207503\n",
      "(Iteration 3901 / 4900) loss: 1.557293\n",
      "(Epoch 8 / 10) train acc: 0.584000; val_acc: 0.504000\n",
      "(Iteration 4001 / 4900) loss: 1.284818\n",
      "(Iteration 4101 / 4900) loss: 1.317599\n",
      "(Iteration 4201 / 4900) loss: 1.236809\n",
      "(Iteration 4301 / 4900) loss: 1.234653\n",
      "(Iteration 4401 / 4900) loss: 1.197693\n",
      "(Epoch 9 / 10) train acc: 0.599000; val_acc: 0.522000\n",
      "(Iteration 4501 / 4900) loss: 1.175673\n",
      "(Iteration 4601 / 4900) loss: 1.368670\n",
      "(Iteration 4701 / 4900) loss: 1.319874\n",
      "(Iteration 4801 / 4900) loss: 1.213929\n",
      "(Epoch 10 / 10) train acc: 0.591000; val_acc: 0.517000\n",
      "100 0.0005 10 0.2\n",
      "Validation accuracy:  0.522\n",
      "(Iteration 1 / 4900) loss: 2.306376\n",
      "(Epoch 0 / 10) train acc: 0.128000; val_acc: 0.091000\n",
      "(Iteration 101 / 4900) loss: 1.968053\n",
      "(Iteration 201 / 4900) loss: 1.795506\n",
      "(Iteration 301 / 4900) loss: 1.688695\n",
      "(Iteration 401 / 4900) loss: 1.698893\n",
      "(Epoch 1 / 10) train acc: 0.443000; val_acc: 0.422000\n",
      "(Iteration 501 / 4900) loss: 1.578453\n",
      "(Iteration 601 / 4900) loss: 1.811937\n",
      "(Iteration 701 / 4900) loss: 1.389429\n",
      "(Iteration 801 / 4900) loss: 1.682822\n",
      "(Iteration 901 / 4900) loss: 1.626164\n",
      "(Epoch 2 / 10) train acc: 0.476000; val_acc: 0.448000\n",
      "(Iteration 1001 / 4900) loss: 1.496729\n",
      "(Iteration 1101 / 4900) loss: 1.450668\n",
      "(Iteration 1201 / 4900) loss: 1.470192\n",
      "(Iteration 1301 / 4900) loss: 1.403123\n",
      "(Iteration 1401 / 4900) loss: 1.470744\n",
      "(Epoch 3 / 10) train acc: 0.498000; val_acc: 0.453000\n",
      "(Iteration 1501 / 4900) loss: 1.477610\n",
      "(Iteration 1601 / 4900) loss: 1.489835\n",
      "(Iteration 1701 / 4900) loss: 1.368167\n",
      "(Iteration 1801 / 4900) loss: 1.355810\n",
      "(Iteration 1901 / 4900) loss: 1.499884\n",
      "(Epoch 4 / 10) train acc: 0.511000; val_acc: 0.457000\n",
      "(Iteration 2001 / 4900) loss: 1.479287\n",
      "(Iteration 2101 / 4900) loss: 1.287936\n",
      "(Iteration 2201 / 4900) loss: 1.299273\n",
      "(Iteration 2301 / 4900) loss: 1.395636\n",
      "(Iteration 2401 / 4900) loss: 1.417605\n",
      "(Epoch 5 / 10) train acc: 0.534000; val_acc: 0.470000\n",
      "(Iteration 2501 / 4900) loss: 1.473756\n",
      "(Iteration 2601 / 4900) loss: 1.340817\n",
      "(Iteration 2701 / 4900) loss: 1.448535\n",
      "(Iteration 2801 / 4900) loss: 1.547251\n",
      "(Iteration 2901 / 4900) loss: 1.316979\n",
      "(Epoch 6 / 10) train acc: 0.536000; val_acc: 0.481000\n",
      "(Iteration 3001 / 4900) loss: 1.393798\n",
      "(Iteration 3101 / 4900) loss: 1.254654\n",
      "(Iteration 3201 / 4900) loss: 1.320680\n",
      "(Iteration 3301 / 4900) loss: 1.440313\n",
      "(Iteration 3401 / 4900) loss: 1.315725\n",
      "(Epoch 7 / 10) train acc: 0.558000; val_acc: 0.487000\n",
      "(Iteration 3501 / 4900) loss: 1.191816\n",
      "(Iteration 3601 / 4900) loss: 1.633455\n",
      "(Iteration 3701 / 4900) loss: 1.350866\n",
      "(Iteration 3801 / 4900) loss: 1.248861\n",
      "(Iteration 3901 / 4900) loss: 1.379294\n",
      "(Epoch 8 / 10) train acc: 0.552000; val_acc: 0.515000\n",
      "(Iteration 4001 / 4900) loss: 1.348113\n",
      "(Iteration 4101 / 4900) loss: 0.978446\n",
      "(Iteration 4201 / 4900) loss: 1.281678\n",
      "(Iteration 4301 / 4900) loss: 1.328882\n",
      "(Iteration 4401 / 4900) loss: 1.083601\n",
      "(Epoch 9 / 10) train acc: 0.546000; val_acc: 0.506000\n",
      "(Iteration 4501 / 4900) loss: 1.397182\n",
      "(Iteration 4601 / 4900) loss: 1.244084\n",
      "(Iteration 4701 / 4900) loss: 1.363915\n",
      "(Iteration 4801 / 4900) loss: 1.238940\n",
      "(Epoch 10 / 10) train acc: 0.576000; val_acc: 0.507000\n",
      "50 0.001 10 0.05\n",
      "Validation accuracy:  0.515\n",
      "(Iteration 1 / 4900) loss: 2.310941\n",
      "(Epoch 0 / 10) train acc: 0.147000; val_acc: 0.133000\n",
      "(Iteration 101 / 4900) loss: 1.815579\n",
      "(Iteration 201 / 4900) loss: 1.650897\n",
      "(Iteration 301 / 4900) loss: 1.673856\n",
      "(Iteration 401 / 4900) loss: 1.583067\n",
      "(Epoch 1 / 10) train acc: 0.448000; val_acc: 0.418000\n",
      "(Iteration 501 / 4900) loss: 1.559151\n",
      "(Iteration 601 / 4900) loss: 1.436711\n",
      "(Iteration 701 / 4900) loss: 1.517318\n",
      "(Iteration 801 / 4900) loss: 1.721321\n",
      "(Iteration 901 / 4900) loss: 1.786317\n",
      "(Epoch 2 / 10) train acc: 0.471000; val_acc: 0.485000\n",
      "(Iteration 1001 / 4900) loss: 1.645742\n",
      "(Iteration 1101 / 4900) loss: 1.565450\n",
      "(Iteration 1201 / 4900) loss: 1.499205\n",
      "(Iteration 1301 / 4900) loss: 1.524392\n",
      "(Iteration 1401 / 4900) loss: 1.504155\n",
      "(Epoch 3 / 10) train acc: 0.479000; val_acc: 0.469000\n",
      "(Iteration 1501 / 4900) loss: 1.426812\n",
      "(Iteration 1601 / 4900) loss: 1.515377\n",
      "(Iteration 1701 / 4900) loss: 1.349148\n",
      "(Iteration 1801 / 4900) loss: 1.335339\n",
      "(Iteration 1901 / 4900) loss: 1.560952\n",
      "(Epoch 4 / 10) train acc: 0.508000; val_acc: 0.465000\n",
      "(Iteration 2001 / 4900) loss: 1.344557\n",
      "(Iteration 2101 / 4900) loss: 1.309548\n",
      "(Iteration 2201 / 4900) loss: 1.335416\n",
      "(Iteration 2301 / 4900) loss: 1.300961\n",
      "(Iteration 2401 / 4900) loss: 1.307104\n",
      "(Epoch 5 / 10) train acc: 0.504000; val_acc: 0.495000\n",
      "(Iteration 2501 / 4900) loss: 1.339334\n",
      "(Iteration 2601 / 4900) loss: 1.421365\n",
      "(Iteration 2701 / 4900) loss: 1.548140\n",
      "(Iteration 2801 / 4900) loss: 1.648623\n",
      "(Iteration 2901 / 4900) loss: 1.242430\n",
      "(Epoch 6 / 10) train acc: 0.519000; val_acc: 0.482000\n",
      "(Iteration 3001 / 4900) loss: 1.474899\n",
      "(Iteration 3101 / 4900) loss: 1.374013\n",
      "(Iteration 3201 / 4900) loss: 1.561666\n",
      "(Iteration 3301 / 4900) loss: 1.376624\n",
      "(Iteration 3401 / 4900) loss: 1.299479\n",
      "(Epoch 7 / 10) train acc: 0.555000; val_acc: 0.491000\n",
      "(Iteration 3501 / 4900) loss: 1.309522\n",
      "(Iteration 3601 / 4900) loss: 1.325283\n",
      "(Iteration 3701 / 4900) loss: 1.526931\n",
      "(Iteration 3801 / 4900) loss: 1.296647\n",
      "(Iteration 3901 / 4900) loss: 1.360394\n",
      "(Epoch 8 / 10) train acc: 0.572000; val_acc: 0.492000\n",
      "(Iteration 4001 / 4900) loss: 1.255402\n",
      "(Iteration 4101 / 4900) loss: 1.242832\n",
      "(Iteration 4201 / 4900) loss: 1.391524\n",
      "(Iteration 4301 / 4900) loss: 1.392933\n",
      "(Iteration 4401 / 4900) loss: 1.495430\n",
      "(Epoch 9 / 10) train acc: 0.578000; val_acc: 0.514000\n",
      "(Iteration 4501 / 4900) loss: 1.298967\n",
      "(Iteration 4601 / 4900) loss: 1.301711\n",
      "(Iteration 4701 / 4900) loss: 1.187888\n",
      "(Iteration 4801 / 4900) loss: 1.173660\n",
      "(Epoch 10 / 10) train acc: 0.576000; val_acc: 0.492000\n",
      "50 0.001 10 0.1\n",
      "Validation accuracy:  0.514\n",
      "(Iteration 1 / 4900) loss: 2.317444\n",
      "(Epoch 0 / 10) train acc: 0.117000; val_acc: 0.132000\n",
      "(Iteration 101 / 4900) loss: 1.869479\n",
      "(Iteration 201 / 4900) loss: 1.757355\n",
      "(Iteration 301 / 4900) loss: 1.670007\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 401 / 4900) loss: 1.589047\n",
      "(Epoch 1 / 10) train acc: 0.439000; val_acc: 0.449000\n",
      "(Iteration 501 / 4900) loss: 1.627427\n",
      "(Iteration 601 / 4900) loss: 1.731244\n",
      "(Iteration 701 / 4900) loss: 1.643446\n",
      "(Iteration 801 / 4900) loss: 1.506963\n",
      "(Iteration 901 / 4900) loss: 1.515133\n",
      "(Epoch 2 / 10) train acc: 0.477000; val_acc: 0.441000\n",
      "(Iteration 1001 / 4900) loss: 1.585581\n",
      "(Iteration 1101 / 4900) loss: 1.585345\n",
      "(Iteration 1201 / 4900) loss: 1.451896\n",
      "(Iteration 1301 / 4900) loss: 1.529187\n",
      "(Iteration 1401 / 4900) loss: 1.576266\n",
      "(Epoch 3 / 10) train acc: 0.470000; val_acc: 0.473000\n",
      "(Iteration 1501 / 4900) loss: 1.540907\n",
      "(Iteration 1601 / 4900) loss: 1.356816\n",
      "(Iteration 1701 / 4900) loss: 1.515117\n",
      "(Iteration 1801 / 4900) loss: 1.470761\n",
      "(Iteration 1901 / 4900) loss: 1.509000\n",
      "(Epoch 4 / 10) train acc: 0.493000; val_acc: 0.460000\n",
      "(Iteration 2001 / 4900) loss: 1.494033\n",
      "(Iteration 2101 / 4900) loss: 1.351997\n",
      "(Iteration 2201 / 4900) loss: 1.399663\n",
      "(Iteration 2301 / 4900) loss: 1.372090\n",
      "(Iteration 2401 / 4900) loss: 1.623593\n",
      "(Epoch 5 / 10) train acc: 0.538000; val_acc: 0.461000\n",
      "(Iteration 2501 / 4900) loss: 1.493464\n",
      "(Iteration 2601 / 4900) loss: 1.293080\n",
      "(Iteration 2701 / 4900) loss: 1.389148\n",
      "(Iteration 2801 / 4900) loss: 1.190320\n",
      "(Iteration 2901 / 4900) loss: 1.377691\n",
      "(Epoch 6 / 10) train acc: 0.534000; val_acc: 0.474000\n",
      "(Iteration 3001 / 4900) loss: 1.620717\n",
      "(Iteration 3101 / 4900) loss: 1.464270\n",
      "(Iteration 3201 / 4900) loss: 1.576906\n",
      "(Iteration 3301 / 4900) loss: 1.630600\n",
      "(Iteration 3401 / 4900) loss: 1.623914\n",
      "(Epoch 7 / 10) train acc: 0.518000; val_acc: 0.456000\n",
      "(Iteration 3501 / 4900) loss: 1.291660\n",
      "(Iteration 3601 / 4900) loss: 1.385871\n",
      "(Iteration 3701 / 4900) loss: 1.523032\n",
      "(Iteration 3801 / 4900) loss: 1.312178\n",
      "(Iteration 3901 / 4900) loss: 1.389757\n",
      "(Epoch 8 / 10) train acc: 0.582000; val_acc: 0.494000\n",
      "(Iteration 4001 / 4900) loss: 1.528039\n",
      "(Iteration 4101 / 4900) loss: 1.267230\n",
      "(Iteration 4201 / 4900) loss: 1.416877\n",
      "(Iteration 4301 / 4900) loss: 1.334524\n",
      "(Iteration 4401 / 4900) loss: 1.418848\n",
      "(Epoch 9 / 10) train acc: 0.546000; val_acc: 0.491000\n",
      "(Iteration 4501 / 4900) loss: 1.292905\n",
      "(Iteration 4601 / 4900) loss: 1.276238\n",
      "(Iteration 4701 / 4900) loss: 1.334431\n",
      "(Iteration 4801 / 4900) loss: 1.450163\n",
      "(Epoch 10 / 10) train acc: 0.579000; val_acc: 0.483000\n",
      "50 0.001 10 0.2\n",
      "Validation accuracy:  0.494\n",
      "(Iteration 1 / 4900) loss: 2.306710\n",
      "(Epoch 0 / 10) train acc: 0.141000; val_acc: 0.131000\n",
      "(Iteration 101 / 4900) loss: 1.732390\n",
      "(Iteration 201 / 4900) loss: 1.742770\n",
      "(Iteration 301 / 4900) loss: 1.650856\n",
      "(Iteration 401 / 4900) loss: 1.527744\n",
      "(Epoch 1 / 10) train acc: 0.459000; val_acc: 0.469000\n",
      "(Iteration 501 / 4900) loss: 1.512665\n",
      "(Iteration 601 / 4900) loss: 1.473862\n",
      "(Iteration 701 / 4900) loss: 1.678722\n",
      "(Iteration 801 / 4900) loss: 1.384904\n",
      "(Iteration 901 / 4900) loss: 1.409121\n",
      "(Epoch 2 / 10) train acc: 0.481000; val_acc: 0.458000\n",
      "(Iteration 1001 / 4900) loss: 1.497028\n",
      "(Iteration 1101 / 4900) loss: 1.479420\n",
      "(Iteration 1201 / 4900) loss: 1.444051\n",
      "(Iteration 1301 / 4900) loss: 1.207757\n",
      "(Iteration 1401 / 4900) loss: 1.328986\n",
      "(Epoch 3 / 10) train acc: 0.529000; val_acc: 0.479000\n",
      "(Iteration 1501 / 4900) loss: 1.313784\n",
      "(Iteration 1601 / 4900) loss: 1.408599\n",
      "(Iteration 1701 / 4900) loss: 1.366732\n",
      "(Iteration 1801 / 4900) loss: 1.418662\n",
      "(Iteration 1901 / 4900) loss: 1.291400\n",
      "(Epoch 4 / 10) train acc: 0.546000; val_acc: 0.502000\n",
      "(Iteration 2001 / 4900) loss: 1.463345\n",
      "(Iteration 2101 / 4900) loss: 1.397596\n",
      "(Iteration 2201 / 4900) loss: 1.434115\n",
      "(Iteration 2301 / 4900) loss: 1.418424\n",
      "(Iteration 2401 / 4900) loss: 1.244870\n",
      "(Epoch 5 / 10) train acc: 0.542000; val_acc: 0.477000\n",
      "(Iteration 2501 / 4900) loss: 1.341580\n",
      "(Iteration 2601 / 4900) loss: 1.499373\n",
      "(Iteration 2701 / 4900) loss: 1.315942\n",
      "(Iteration 2801 / 4900) loss: 1.303938\n",
      "(Iteration 2901 / 4900) loss: 1.206006\n",
      "(Epoch 6 / 10) train acc: 0.547000; val_acc: 0.485000\n",
      "(Iteration 3001 / 4900) loss: 1.386571\n",
      "(Iteration 3101 / 4900) loss: 1.249132\n",
      "(Iteration 3201 / 4900) loss: 1.268382\n",
      "(Iteration 3301 / 4900) loss: 1.167421\n",
      "(Iteration 3401 / 4900) loss: 1.198494\n",
      "(Epoch 7 / 10) train acc: 0.566000; val_acc: 0.494000\n",
      "(Iteration 3501 / 4900) loss: 1.269799\n",
      "(Iteration 3601 / 4900) loss: 1.095474\n",
      "(Iteration 3701 / 4900) loss: 1.431186\n",
      "(Iteration 3801 / 4900) loss: 1.078250\n",
      "(Iteration 3901 / 4900) loss: 1.245378\n",
      "(Epoch 8 / 10) train acc: 0.605000; val_acc: 0.518000\n",
      "(Iteration 4001 / 4900) loss: 1.378459\n",
      "(Iteration 4101 / 4900) loss: 1.576932\n",
      "(Iteration 4201 / 4900) loss: 1.418471\n",
      "(Iteration 4301 / 4900) loss: 1.387678\n",
      "(Iteration 4401 / 4900) loss: 1.366879\n",
      "(Epoch 9 / 10) train acc: 0.588000; val_acc: 0.489000\n",
      "(Iteration 4501 / 4900) loss: 1.310895\n",
      "(Iteration 4601 / 4900) loss: 1.051867\n",
      "(Iteration 4701 / 4900) loss: 1.229002\n",
      "(Iteration 4801 / 4900) loss: 1.395103\n",
      "(Epoch 10 / 10) train acc: 0.584000; val_acc: 0.509000\n",
      "80 0.001 10 0.05\n",
      "Validation accuracy:  0.518\n",
      "(Iteration 1 / 4900) loss: 2.312005\n",
      "(Epoch 0 / 10) train acc: 0.153000; val_acc: 0.121000\n",
      "(Iteration 101 / 4900) loss: 1.859294\n",
      "(Iteration 201 / 4900) loss: 1.619645\n",
      "(Iteration 301 / 4900) loss: 1.632837\n",
      "(Iteration 401 / 4900) loss: 1.539462\n",
      "(Epoch 1 / 10) train acc: 0.470000; val_acc: 0.443000\n",
      "(Iteration 501 / 4900) loss: 1.697383\n",
      "(Iteration 601 / 4900) loss: 1.429850\n",
      "(Iteration 701 / 4900) loss: 1.580751\n",
      "(Iteration 801 / 4900) loss: 1.571767\n",
      "(Iteration 901 / 4900) loss: 1.694968\n",
      "(Epoch 2 / 10) train acc: 0.494000; val_acc: 0.480000\n",
      "(Iteration 1001 / 4900) loss: 1.340494\n",
      "(Iteration 1101 / 4900) loss: 1.599851\n",
      "(Iteration 1201 / 4900) loss: 1.343883\n",
      "(Iteration 1301 / 4900) loss: 1.632565\n",
      "(Iteration 1401 / 4900) loss: 1.591299\n",
      "(Epoch 3 / 10) train acc: 0.511000; val_acc: 0.466000\n",
      "(Iteration 1501 / 4900) loss: 1.524694\n",
      "(Iteration 1601 / 4900) loss: 1.379135\n",
      "(Iteration 1701 / 4900) loss: 1.285221\n",
      "(Iteration 1801 / 4900) loss: 1.390848\n",
      "(Iteration 1901 / 4900) loss: 1.293988\n",
      "(Epoch 4 / 10) train acc: 0.539000; val_acc: 0.487000\n",
      "(Iteration 2001 / 4900) loss: 1.373792\n",
      "(Iteration 2101 / 4900) loss: 1.230650\n",
      "(Iteration 2201 / 4900) loss: 1.343791\n",
      "(Iteration 2301 / 4900) loss: 1.407919\n",
      "(Iteration 2401 / 4900) loss: 1.239101\n",
      "(Epoch 5 / 10) train acc: 0.544000; val_acc: 0.498000\n",
      "(Iteration 2501 / 4900) loss: 1.358281\n",
      "(Iteration 2601 / 4900) loss: 1.312766\n",
      "(Iteration 2701 / 4900) loss: 1.210982\n",
      "(Iteration 2801 / 4900) loss: 1.361587\n",
      "(Iteration 2901 / 4900) loss: 1.279684\n",
      "(Epoch 6 / 10) train acc: 0.531000; val_acc: 0.503000\n",
      "(Iteration 3001 / 4900) loss: 1.282416\n",
      "(Iteration 3101 / 4900) loss: 1.303536\n",
      "(Iteration 3201 / 4900) loss: 1.393232\n",
      "(Iteration 3301 / 4900) loss: 1.487616\n",
      "(Iteration 3401 / 4900) loss: 1.276769\n",
      "(Epoch 7 / 10) train acc: 0.575000; val_acc: 0.502000\n",
      "(Iteration 3501 / 4900) loss: 1.131569\n",
      "(Iteration 3601 / 4900) loss: 1.187242\n",
      "(Iteration 3701 / 4900) loss: 1.376745\n",
      "(Iteration 3801 / 4900) loss: 1.122737\n",
      "(Iteration 3901 / 4900) loss: 1.204673\n",
      "(Epoch 8 / 10) train acc: 0.546000; val_acc: 0.482000\n",
      "(Iteration 4001 / 4900) loss: 1.233714\n",
      "(Iteration 4101 / 4900) loss: 1.398106\n",
      "(Iteration 4201 / 4900) loss: 1.073088\n",
      "(Iteration 4301 / 4900) loss: 1.191304\n",
      "(Iteration 4401 / 4900) loss: 1.299698\n",
      "(Epoch 9 / 10) train acc: 0.587000; val_acc: 0.496000\n",
      "(Iteration 4501 / 4900) loss: 1.348409\n",
      "(Iteration 4601 / 4900) loss: 1.289006\n",
      "(Iteration 4701 / 4900) loss: 1.453829\n",
      "(Iteration 4801 / 4900) loss: 1.275211\n",
      "(Epoch 10 / 10) train acc: 0.591000; val_acc: 0.529000\n",
      "80 0.001 10 0.1\n",
      "Validation accuracy:  0.529\n",
      "(Iteration 1 / 4900) loss: 2.326511\n",
      "(Epoch 0 / 10) train acc: 0.098000; val_acc: 0.104000\n",
      "(Iteration 101 / 4900) loss: 1.929740\n",
      "(Iteration 201 / 4900) loss: 1.781381\n",
      "(Iteration 301 / 4900) loss: 1.711898\n",
      "(Iteration 401 / 4900) loss: 1.682598\n",
      "(Epoch 1 / 10) train acc: 0.431000; val_acc: 0.442000\n",
      "(Iteration 501 / 4900) loss: 1.534532\n",
      "(Iteration 601 / 4900) loss: 1.635863\n",
      "(Iteration 701 / 4900) loss: 1.370932\n",
      "(Iteration 801 / 4900) loss: 1.577017\n",
      "(Iteration 901 / 4900) loss: 1.569573\n",
      "(Epoch 2 / 10) train acc: 0.524000; val_acc: 0.464000\n",
      "(Iteration 1001 / 4900) loss: 1.703042\n",
      "(Iteration 1101 / 4900) loss: 1.590660\n",
      "(Iteration 1201 / 4900) loss: 1.594052\n",
      "(Iteration 1301 / 4900) loss: 1.446175\n",
      "(Iteration 1401 / 4900) loss: 1.349081\n",
      "(Epoch 3 / 10) train acc: 0.501000; val_acc: 0.461000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1501 / 4900) loss: 1.508559\n",
      "(Iteration 1601 / 4900) loss: 1.327219\n",
      "(Iteration 1701 / 4900) loss: 1.322682\n",
      "(Iteration 1801 / 4900) loss: 1.578238\n",
      "(Iteration 1901 / 4900) loss: 1.510904\n",
      "(Epoch 4 / 10) train acc: 0.525000; val_acc: 0.494000\n",
      "(Iteration 2001 / 4900) loss: 1.409519\n",
      "(Iteration 2101 / 4900) loss: 1.576437\n",
      "(Iteration 2201 / 4900) loss: 1.333332\n",
      "(Iteration 2301 / 4900) loss: 1.545389\n",
      "(Iteration 2401 / 4900) loss: 1.539115\n",
      "(Epoch 5 / 10) train acc: 0.525000; val_acc: 0.479000\n",
      "(Iteration 2501 / 4900) loss: 1.355556\n",
      "(Iteration 2601 / 4900) loss: 1.156507\n",
      "(Iteration 2701 / 4900) loss: 1.313451\n",
      "(Iteration 2801 / 4900) loss: 1.407977\n",
      "(Iteration 2901 / 4900) loss: 1.437578\n",
      "(Epoch 6 / 10) train acc: 0.551000; val_acc: 0.502000\n",
      "(Iteration 3001 / 4900) loss: 1.321325\n",
      "(Iteration 3101 / 4900) loss: 1.491294\n",
      "(Iteration 3201 / 4900) loss: 1.396417\n",
      "(Iteration 3301 / 4900) loss: 1.202560\n",
      "(Iteration 3401 / 4900) loss: 1.434511\n",
      "(Epoch 7 / 10) train acc: 0.560000; val_acc: 0.484000\n",
      "(Iteration 3501 / 4900) loss: 1.206534\n",
      "(Iteration 3601 / 4900) loss: 1.291341\n",
      "(Iteration 3701 / 4900) loss: 1.307824\n",
      "(Iteration 3801 / 4900) loss: 1.240818\n",
      "(Iteration 3901 / 4900) loss: 1.471252\n",
      "(Epoch 8 / 10) train acc: 0.582000; val_acc: 0.513000\n",
      "(Iteration 4001 / 4900) loss: 1.363779\n",
      "(Iteration 4101 / 4900) loss: 1.292138\n",
      "(Iteration 4201 / 4900) loss: 1.328515\n",
      "(Iteration 4301 / 4900) loss: 1.154053\n",
      "(Iteration 4401 / 4900) loss: 1.173543\n",
      "(Epoch 9 / 10) train acc: 0.568000; val_acc: 0.485000\n",
      "(Iteration 4501 / 4900) loss: 1.026396\n",
      "(Iteration 4601 / 4900) loss: 1.330261\n",
      "(Iteration 4701 / 4900) loss: 1.308040\n",
      "(Iteration 4801 / 4900) loss: 1.257201\n",
      "(Epoch 10 / 10) train acc: 0.593000; val_acc: 0.499000\n",
      "80 0.001 10 0.2\n",
      "Validation accuracy:  0.513\n",
      "(Iteration 1 / 4900) loss: 2.308486\n",
      "(Epoch 0 / 10) train acc: 0.152000; val_acc: 0.125000\n",
      "(Iteration 101 / 4900) loss: 1.922931\n",
      "(Iteration 201 / 4900) loss: 1.809577\n",
      "(Iteration 301 / 4900) loss: 1.540078\n",
      "(Iteration 401 / 4900) loss: 1.541552\n",
      "(Epoch 1 / 10) train acc: 0.439000; val_acc: 0.432000\n",
      "(Iteration 501 / 4900) loss: 1.443680\n",
      "(Iteration 601 / 4900) loss: 1.608566\n",
      "(Iteration 701 / 4900) loss: 1.402056\n",
      "(Iteration 801 / 4900) loss: 1.479109\n",
      "(Iteration 901 / 4900) loss: 1.296555\n",
      "(Epoch 2 / 10) train acc: 0.470000; val_acc: 0.466000\n",
      "(Iteration 1001 / 4900) loss: 1.422531\n",
      "(Iteration 1101 / 4900) loss: 1.219960\n",
      "(Iteration 1201 / 4900) loss: 1.366990\n",
      "(Iteration 1301 / 4900) loss: 1.440781\n",
      "(Iteration 1401 / 4900) loss: 1.414657\n",
      "(Epoch 3 / 10) train acc: 0.505000; val_acc: 0.463000\n",
      "(Iteration 1501 / 4900) loss: 1.426187\n",
      "(Iteration 1601 / 4900) loss: 1.375295\n",
      "(Iteration 1701 / 4900) loss: 1.509882\n",
      "(Iteration 1801 / 4900) loss: 1.235003\n",
      "(Iteration 1901 / 4900) loss: 1.241517\n",
      "(Epoch 4 / 10) train acc: 0.495000; val_acc: 0.461000\n",
      "(Iteration 2001 / 4900) loss: 1.250819\n",
      "(Iteration 2101 / 4900) loss: 1.373311\n",
      "(Iteration 2201 / 4900) loss: 1.435992\n",
      "(Iteration 2301 / 4900) loss: 1.444136\n",
      "(Iteration 2401 / 4900) loss: 1.202355\n",
      "(Epoch 5 / 10) train acc: 0.526000; val_acc: 0.497000\n",
      "(Iteration 2501 / 4900) loss: 1.405112\n",
      "(Iteration 2601 / 4900) loss: 1.271651\n",
      "(Iteration 2701 / 4900) loss: 1.253989\n",
      "(Iteration 2801 / 4900) loss: 1.215329\n",
      "(Iteration 2901 / 4900) loss: 1.319666\n",
      "(Epoch 6 / 10) train acc: 0.564000; val_acc: 0.515000\n",
      "(Iteration 3001 / 4900) loss: 1.171646\n",
      "(Iteration 3101 / 4900) loss: 1.332994\n",
      "(Iteration 3201 / 4900) loss: 1.488350\n",
      "(Iteration 3301 / 4900) loss: 1.343982\n",
      "(Iteration 3401 / 4900) loss: 1.329468\n",
      "(Epoch 7 / 10) train acc: 0.544000; val_acc: 0.487000\n",
      "(Iteration 3501 / 4900) loss: 1.226476\n",
      "(Iteration 3601 / 4900) loss: 1.127571\n",
      "(Iteration 3701 / 4900) loss: 1.341693\n",
      "(Iteration 3801 / 4900) loss: 1.496654\n",
      "(Iteration 3901 / 4900) loss: 1.058637\n",
      "(Epoch 8 / 10) train acc: 0.580000; val_acc: 0.494000\n",
      "(Iteration 4001 / 4900) loss: 1.417538\n",
      "(Iteration 4101 / 4900) loss: 1.203043\n",
      "(Iteration 4201 / 4900) loss: 1.242181\n",
      "(Iteration 4301 / 4900) loss: 1.259067\n",
      "(Iteration 4401 / 4900) loss: 1.046356\n",
      "(Epoch 9 / 10) train acc: 0.577000; val_acc: 0.507000\n",
      "(Iteration 4501 / 4900) loss: 1.091907\n",
      "(Iteration 4601 / 4900) loss: 1.261654\n",
      "(Iteration 4701 / 4900) loss: 1.182365\n",
      "(Iteration 4801 / 4900) loss: 1.221868\n",
      "(Epoch 10 / 10) train acc: 0.600000; val_acc: 0.512000\n",
      "100 0.001 10 0.05\n",
      "Validation accuracy:  0.515\n",
      "(Iteration 1 / 4900) loss: 2.321918\n",
      "(Epoch 0 / 10) train acc: 0.130000; val_acc: 0.117000\n",
      "(Iteration 101 / 4900) loss: 1.679333\n",
      "(Iteration 201 / 4900) loss: 1.618633\n",
      "(Iteration 301 / 4900) loss: 1.659564\n",
      "(Iteration 401 / 4900) loss: 1.653375\n",
      "(Epoch 1 / 10) train acc: 0.452000; val_acc: 0.444000\n",
      "(Iteration 501 / 4900) loss: 1.576577\n",
      "(Iteration 601 / 4900) loss: 1.508818\n",
      "(Iteration 701 / 4900) loss: 1.540759\n",
      "(Iteration 801 / 4900) loss: 1.487839\n",
      "(Iteration 901 / 4900) loss: 1.391114\n",
      "(Epoch 2 / 10) train acc: 0.482000; val_acc: 0.446000\n",
      "(Iteration 1001 / 4900) loss: 1.533926\n",
      "(Iteration 1101 / 4900) loss: 1.375652\n",
      "(Iteration 1201 / 4900) loss: 1.353281\n",
      "(Iteration 1301 / 4900) loss: 1.389892\n",
      "(Iteration 1401 / 4900) loss: 1.188994\n",
      "(Epoch 3 / 10) train acc: 0.517000; val_acc: 0.472000\n",
      "(Iteration 1501 / 4900) loss: 1.281121\n",
      "(Iteration 1601 / 4900) loss: 1.322450\n",
      "(Iteration 1701 / 4900) loss: 1.527342\n",
      "(Iteration 1801 / 4900) loss: 1.216132\n",
      "(Iteration 1901 / 4900) loss: 1.490837\n",
      "(Epoch 4 / 10) train acc: 0.512000; val_acc: 0.494000\n",
      "(Iteration 2001 / 4900) loss: 1.470521\n",
      "(Iteration 2101 / 4900) loss: 1.183784\n",
      "(Iteration 2201 / 4900) loss: 1.010955\n",
      "(Iteration 2301 / 4900) loss: 1.259007\n",
      "(Iteration 2401 / 4900) loss: 1.367298\n",
      "(Epoch 5 / 10) train acc: 0.532000; val_acc: 0.481000\n",
      "(Iteration 2501 / 4900) loss: 1.167413\n",
      "(Iteration 2601 / 4900) loss: 1.632966\n",
      "(Iteration 2701 / 4900) loss: 1.253750\n",
      "(Iteration 2801 / 4900) loss: 1.324841\n",
      "(Iteration 2901 / 4900) loss: 1.168418\n",
      "(Epoch 6 / 10) train acc: 0.577000; val_acc: 0.497000\n",
      "(Iteration 3001 / 4900) loss: 1.286327\n",
      "(Iteration 3101 / 4900) loss: 1.485210\n",
      "(Iteration 3201 / 4900) loss: 1.483361\n",
      "(Iteration 3301 / 4900) loss: 1.420331\n",
      "(Iteration 3401 / 4900) loss: 1.510935\n",
      "(Epoch 7 / 10) train acc: 0.559000; val_acc: 0.492000\n",
      "(Iteration 3501 / 4900) loss: 0.987821\n",
      "(Iteration 3601 / 4900) loss: 1.622838\n",
      "(Iteration 3701 / 4900) loss: 1.116039\n",
      "(Iteration 3801 / 4900) loss: 1.494108\n",
      "(Iteration 3901 / 4900) loss: 1.249379\n",
      "(Epoch 8 / 10) train acc: 0.575000; val_acc: 0.499000\n",
      "(Iteration 4001 / 4900) loss: 1.377437\n",
      "(Iteration 4101 / 4900) loss: 1.193184\n",
      "(Iteration 4201 / 4900) loss: 1.357316\n",
      "(Iteration 4301 / 4900) loss: 1.291267\n",
      "(Iteration 4401 / 4900) loss: 1.244584\n",
      "(Epoch 9 / 10) train acc: 0.579000; val_acc: 0.502000\n",
      "(Iteration 4501 / 4900) loss: 1.241782\n",
      "(Iteration 4601 / 4900) loss: 1.205636\n",
      "(Iteration 4701 / 4900) loss: 1.189954\n",
      "(Iteration 4801 / 4900) loss: 1.254808\n",
      "(Epoch 10 / 10) train acc: 0.598000; val_acc: 0.510000\n",
      "100 0.001 10 0.1\n",
      "Validation accuracy:  0.51\n",
      "(Iteration 1 / 4900) loss: 2.337568\n",
      "(Epoch 0 / 10) train acc: 0.136000; val_acc: 0.120000\n",
      "(Iteration 101 / 4900) loss: 1.770773\n",
      "(Iteration 201 / 4900) loss: 1.750828\n",
      "(Iteration 301 / 4900) loss: 1.702341\n",
      "(Iteration 401 / 4900) loss: 1.582437\n",
      "(Epoch 1 / 10) train acc: 0.437000; val_acc: 0.451000\n",
      "(Iteration 501 / 4900) loss: 1.879218\n",
      "(Iteration 601 / 4900) loss: 1.544451\n",
      "(Iteration 701 / 4900) loss: 1.638399\n",
      "(Iteration 801 / 4900) loss: 1.786267\n",
      "(Iteration 901 / 4900) loss: 1.436558\n",
      "(Epoch 2 / 10) train acc: 0.517000; val_acc: 0.476000\n",
      "(Iteration 1001 / 4900) loss: 1.510191\n",
      "(Iteration 1101 / 4900) loss: 1.545195\n",
      "(Iteration 1201 / 4900) loss: 1.708306\n",
      "(Iteration 1301 / 4900) loss: 1.545840\n",
      "(Iteration 1401 / 4900) loss: 1.692846\n",
      "(Epoch 3 / 10) train acc: 0.510000; val_acc: 0.468000\n",
      "(Iteration 1501 / 4900) loss: 1.421681\n",
      "(Iteration 1601 / 4900) loss: 1.428859\n",
      "(Iteration 1701 / 4900) loss: 1.400838\n",
      "(Iteration 1801 / 4900) loss: 1.507399\n",
      "(Iteration 1901 / 4900) loss: 1.264218\n",
      "(Epoch 4 / 10) train acc: 0.541000; val_acc: 0.501000\n",
      "(Iteration 2001 / 4900) loss: 1.305573\n",
      "(Iteration 2101 / 4900) loss: 1.309877\n",
      "(Iteration 2201 / 4900) loss: 1.550370\n",
      "(Iteration 2301 / 4900) loss: 1.282392\n",
      "(Iteration 2401 / 4900) loss: 1.327018\n",
      "(Epoch 5 / 10) train acc: 0.537000; val_acc: 0.508000\n",
      "(Iteration 2501 / 4900) loss: 1.303140\n",
      "(Iteration 2601 / 4900) loss: 1.241635\n",
      "(Iteration 2701 / 4900) loss: 1.431255\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 2801 / 4900) loss: 1.398697\n",
      "(Iteration 2901 / 4900) loss: 1.585883\n",
      "(Epoch 6 / 10) train acc: 0.551000; val_acc: 0.489000\n",
      "(Iteration 3001 / 4900) loss: 1.336182\n",
      "(Iteration 3101 / 4900) loss: 1.345833\n",
      "(Iteration 3201 / 4900) loss: 1.438816\n",
      "(Iteration 3301 / 4900) loss: 1.285172\n",
      "(Iteration 3401 / 4900) loss: 1.370705\n",
      "(Epoch 7 / 10) train acc: 0.572000; val_acc: 0.497000\n",
      "(Iteration 3501 / 4900) loss: 1.448610\n",
      "(Iteration 3601 / 4900) loss: 1.356559\n",
      "(Iteration 3701 / 4900) loss: 1.537923\n",
      "(Iteration 3801 / 4900) loss: 1.266928\n",
      "(Iteration 3901 / 4900) loss: 1.308424\n",
      "(Epoch 8 / 10) train acc: 0.596000; val_acc: 0.518000\n",
      "(Iteration 4001 / 4900) loss: 1.558665\n",
      "(Iteration 4101 / 4900) loss: 1.459895\n",
      "(Iteration 4201 / 4900) loss: 1.240943\n",
      "(Iteration 4301 / 4900) loss: 1.178691\n",
      "(Iteration 4401 / 4900) loss: 1.302572\n",
      "(Epoch 9 / 10) train acc: 0.586000; val_acc: 0.527000\n",
      "(Iteration 4501 / 4900) loss: 1.156914\n",
      "(Iteration 4601 / 4900) loss: 1.046760\n",
      "(Iteration 4701 / 4900) loss: 1.390571\n",
      "(Iteration 4801 / 4900) loss: 1.157498\n",
      "(Epoch 10 / 10) train acc: 0.559000; val_acc: 0.490000\n",
      "100 0.001 10 0.2\n",
      "Validation accuracy:  0.527\n",
      "Validation accuracy:  0.529\n"
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "\n",
    "\n",
    "#################################################################################\n",
    "# TODO: Tune hyperparameters using the validation set. Store your best trained  #\n",
    "# model in best_model.                                                          #\n",
    "#                                                                               #\n",
    "# To help debug your network, it may help to use visualizations similar to the  #\n",
    "# ones we used above; these visualizations will have significant qualitative    #\n",
    "# differences from the ones we saw above for the poorly tuned network.          #\n",
    "#                                                                               #\n",
    "# Tweaking hyperparameters by hand can be fun, but you might find it useful to  #\n",
    "# write code to sweep through possible combinations of hyperparameters          #\n",
    "# automatically like we did on thexs previous exercises.                          #\n",
    "#################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "epo_choice = [10]\n",
    "hsize_choice = [50,80,100]\n",
    "reg_choice = [0.05,0.1,0.2]\n",
    "lr_choice = [5e-5,1e-4,5e-4,1e-3]\n",
    "\n",
    "best_val_accuracy = -1\n",
    "\n",
    "for epo in epo_choice:\n",
    "    for lr in lr_choice:\n",
    "        for hsize in hsize_choice:\n",
    "            for reg in reg_choice:\n",
    "                solver = None\n",
    "                model = TwoLayerNet(input_size, hsize, num_classes, reg = reg)\n",
    "                solver = Solver(model, data,\n",
    "                                update_rule='sgd',\n",
    "                                optim_config={\n",
    "                                  'learning_rate': lr,\n",
    "                                },\n",
    "                                lr_decay=0.95,\n",
    "                                num_epochs=epo, batch_size=100,\n",
    "                                print_every=100, verbose = True)\n",
    "                solver.train()\n",
    "                print(hsize, lr, epo, reg)\n",
    "                print('Validation accuracy: ', solver.best_val_acc)\n",
    "                if solver.best_val_acc > best_val_accuracy:\n",
    "                    best_val_accuracy = solver.best_val_acc\n",
    "                    best_model = model\n",
    "print('Validation accuracy: ', best_val_accuracy)           \n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 48% accuracy on the validation set and the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "val_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.529\n"
     ]
    }
   ],
   "source": [
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "id": "test_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set accuracy:  0.524\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 2: \n",
    "\n",
    "Now that you have trained a Neural Network classifier, you may find that your testing accuracy is much lower than the training accuracy. In what ways can we decrease this gap? Select all that apply.\n",
    "\n",
    "1. Train on a larger dataset.\n",
    "2. Add more hidden units.\n",
    "3. Increase the regularization strength.\n",
    "4. None of the above.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ 1、3\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$ 这说明模型过拟合和训练集。应该适当减少模型参数，增加训练集数据量，所以选1、3。增加隐藏层神经元数会增加模型参数，不可取。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
